"Temporary value dropped while borrowed" when using string.replace()

Question

Can someone explain which exact temporary value is dropped and what the recommended way to do this operation is?

fn main() {
    let mut a = &mut String::from("Hello Ownership");
    a = &mut a.replace("Ownership", "World");
    println!("a is {}", a);
}

Answer 1

If you want to keep the &mut references (which are generally not needed in your case, of course), you can do something like this:

fn main() {
    let a = &mut String::from("Hello Ownership");
    let a = &mut a.replace("Ownership", "World");
    println!("a is {}", a);
}

The type of a would by &mut String. In the second line we do what's known as variable shadowing (not that it's needed) and the type is still &mut String.

That doesn't quite answer your question. I don't know why exactly your version doesn't compile, but at least I thought this info might be useful. (see below)

Update

Thanks to Solomon's findings, I wanted to add that apparently in this case:

let a = &mut ...;
let b = &mut ...;

or this one (variable shadowing, basically the same as the above):

let a = &mut ...;
let a = &mut ...;

, the compiler will automatically extend the lifetime of each temporary until the end of the enclosing block. However, in the case of:

let mut a = &mut ...;
a = &mut ...;

, it seems the compiler simply doesn't do such lifetime extension, so that's why the OP's code doesn't compile, even though the code seems to be doing pretty much the same thing.

Answer 2

Why are you using &mut there? Try this:

fn main() {
    let mut a = String::from("Hello Ownership");
    a = a.replace("Ownership", "World");
    println!("a is {}", a);
}

Answer 3

Aha, figured it out!

https://doc.rust-lang.org/nightly/error-index.html#E0716 says:

Temporaries are not always dropped at the end of the enclosing statement. In simple cases where the & expression is immediately stored into a variable, the compiler will automatically extend the lifetime of the temporary until the end of the enclosing block. Therefore, an alternative way to fix the original program is to write let tmp = &foo() and not let tmp = foo():

fn foo() -> i32 { 22 }
fn bar(x: &i32) -> &i32 { x }
let value = &foo();
let p = bar(value);
let q = *p;

Here, we are still borrowing foo(), but as the borrow is assigned directly into a variable, the temporary will not be dropped until the end of the enclosing block. Similar rules apply when temporaries are stored into aggregate structures like a tuple or struct:

// Here, two temporaries are created, but
// as they are stored directly into `value`,
// they are not dropped until the end of the
// enclosing block.
fn foo() -> i32 { 22 }
let value = (&foo(), &foo());