5

I am trying to understand how lifetimes in Rust affect Structs. Attached is a minimal example that confuses me.

I would like to give a struct a reference to an object and then later it is necessary to change this object. Since it is not possible to change the object while it is borrowed, I thought that I have to remove the reference while changing it. So my idea was to define the variable as an option and remove the reference during the modification of the object by setting it to None. For the example without the use of a Struct this seems to work. However, if I now put this reference into a Struct it does not work. It seems to me that the borrow checker overlooks the fact that the variable string is no longer borrowed. Is there a way to still achieve the desired behaviour with a Struct?

This works (link to playground):

fn main() {
    let mut string = "mutable string".to_string();
    let mut ref_to_string: Option<&str> = Some(&string);
    ref_to_string = None;
    string = "mutated string".to_string();
    ref_to_string = Some(&string);
}

However, this doesn't work link to playground:

struct Foo<'a> {
    pub ref_data: Option<&'a str>,
}

fn main() {
    let mut string = "mutable string".to_string();
    let mut foo = Foo{ref_data: Some(&string)};
    foo.ref_data = None;
    string = "mutated string".to_string();
    foo.ref_data = Some(&string);
}

Error message:

error[E0506]: cannot assign to `string` because it is borrowed
  --> src/main.rs:11:5
   |
9  |     let mut foo = Foo{ref_data: Some(&string)};
   |                                      ------- borrow of `string` occurs here
10 |     foo.ref_data = None;
11 |     string = "mutated string".to_string();
   |     ^^^^^^ assignment to borrowed `string` occurs here
12 |     foo.ref_data = Some(&string);
   |     ---------------------------- borrow later used here

For more information about this error, try `rustc --explain E0506`.
Improve this question
1
  • With the Option, you don't even need ref_to_string = None;. The compiler doesn't care if ref_to_string contains a dangling reference as long as you don't try to use it. Commented Oct 12, 2021 at 14:11

3 Answers 3

Reset to default
2

The problem is that you are referencing the string variable twice. When borrowing the first one is binding the &str lifetime to be alive at least as foo. There should be no problem to reference another string that lives in "another" variable:

fn main() {
    let string = "mutable string".to_string();
    let mut foo = Foo {
        ref_data: Some(&string),
    };
    foo.ref_data = None;

    let string = "mutated string".to_string();
    foo.ref_data = Some(&string);
}

Playground

Notice the use of another let binding instead of mutating the variable.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Thanks for the quick reply and also the suggestion on how to work around the problem. However, it is not completely clear to me why this works. As it was written by user4815162342, the string must still live longer than foo. Doesn't shadowing of string ends it lifetime?
@hochej, it does not older content is droped and it is not referenced by anything already, so no complains by the compiler. What I mean is that you will not be referencing the same one twice, so there is no reborrowing after binded lifetime. I dont know if im explaining myself properly, sorry.
I have changed the code in Playground so that it is clearer what is confusing me about your example. If I redefine string, then the borrow checker seems to agree with it. However, if I then (without re-setting foo.ref_data) output the value of this field (foo.ref_data), then this prints "mutable string". But this string doesn't exist anymore, does it?
@hochej, It DOES exist, because it is not droped till the end of the scope, later after the print.
Ah okay, thanks! I had thought that shadowing variables would drop them automatically. But I just looked in the Rust book and found this helpful info: "Note that shadowing a name does not alter or destroy the value it was bound to, and the value will continue to exist until it goes out of scope, even if it is no longer accessible by any means." Sorry for all my questions. I think I have understood it now.
2

The secret lies in the definition of the Foo struct:

struct Foo<'a> {
    pub ref_data: Option<&'a str>,
}

And more specifically in the 'a lifetime specifier. By specifying that Foo lives for 'a and that ref_data has the same lifetime (&'a str), you say that your &str will live as long as Foo. So as long as Foo is alive, compiler cannot drop the reference to your string.

Unfortunately, there is no way to specify that the struct has lifetime of 'a only while the field is Some.

To mutate an object refenced by a structure, you can:

  1. Transfer ownership of the object to the struct, and then get a mutable reference to it from the struct.
  2. Use internal mutability (see RefCell).
  3. Drop you struct before mutating and recreate it after mutation is finished.

Which approach is better depends on your specific use case.

Improve this answer

Comments

1

The problem is that the whole Foo is generic over a lifetime. That way, when you assigned foo = Foo {ref_data: Some(&string)}, the type of foo is Foo<'lifetime_of_string>. You can set foo.ref_data to None all you want, but as far as borrow checking is concerned, there is still a live object whose lifetime overlaps that of string. For this reason, string is borrowed as long as foo lives. The only way to do it is to drop the whole foo:

let mut string = "mutable string".to_string();
let mut foo = Foo{ref_data: Some(&string)};
drop(foo);
foo = Foo { ref_data: None };
string = "mutated string".to_string();
foo.ref_data = Some(&string);
Improve this answer

2 Comments

you dont need that explicit drop
The type Option<&str> is also generic over a lifetime, and that lifetime is also inferred by the compiler at the time of the first assignment. The difference is that in the case of the struct, the lifetime gets associated with the whole struct, and not only with the field that uses it.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.