Confusing section: Wrapping mltiple mutable references in curly braces

[jish]

Hello, I apologize if this is the incorrect place for book feedback. When looking at the main page and its links, I did not find any other instructions for submitting feedback https://doc.rust-lang.org/book/title-page.html

In Chapter 4 Section 2 https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html about half way down the page is a section that begins with

"As always, we can use curly brackets to create a new scope, allowing for multiple mutable references, just not simultaneous ones:"

    let mut s = String::from("hello");

    {
        let r1 = &mut s;
    } // r1 goes out of scope here, so we can make a new reference with no problems.

    let r2 = &mut s;

I do not understand this suggestion to wrap the first mutable reference in curly braces. I'm attempting to run through some exercises, but I'm having trouble filling in the gaps in this code sample.

Later on down the page it says:

"Note that a reference’s scope starts from where it is introduced and continues through the last time that reference is used."

So if we create a reference and then use it before we create a second reference, the code works fine.

    let mut s = String::from("hello");

    let r1 = &mut s;
    println!("{}", r1);

    let r2 = &mut s;
    println!("{}", r2);

Could you please help me understand how the curly braces from listings/ch04-understanding-ownership/no-listing-11-muts-in-separate-scopes https://github.com/rust-lang/book/blob/2bd5d42c9956369132228da6409f0e68da56c51a/listings/ch04-understanding-ownership/no-listing-11-muts-in-separate-scopes/src/main.rs help with multiple mutable references?

If there is a better place to have this discussion, I apologize and I would be happy to move the topic elsewhere. I just figured that you may appreciate some feedback from a newcomer and a fresh set of eyes. I personally found the curly braces code example to be a bit confusing, and I could use some help understanding it. Maybe it would also help future readers if we could clarify the section in the book about curly braces and mutable references, thanks! 😄

[c-git]

I'm not sure I understood your question. What I understood was you were trying to understand why the curly braces were necessary?

TLDR it used to be necessary but now it is not.

From my understanding, they used to be necessary before support was added for non-lexical lifetimes. And they are not necessary anymore. You can only have 1 mutable reference at a time and because the are in the same lexical scope (some block in the same curtly braces), then the borrow checked used to complain that you are starting a new mutable borrow before you finished with the first one. But now it is able to realize that the first one isn't used anymore and can be released.

[jish]

I'm not sure I understood your question.

I'm sorry, let me try to rephrase it. 😞

As a newcomer to Rust reading through The Rust Programming Language for the first time, what do I need to know about curly braces as they relate to mutable references?

Is some part of the code example missing?

It sounds like maybe this is an old incomplete code example for an old version of Rust. I'm sorry, as I'm new to Rust I don't think I can fully read and digest that RFC until I better understand the language. 😕 Is this feature deprecated? And if so, should old deprecated code that no longer works still be in the book? Or should it be removed?

Or, is there some more detail we can add to that section, in order to clarify the relationship between curly braces and mutable references, so that newcomers can better understand this new and exciting language? 😄

[c-git]

The great part is the old code still works. I think the problem that the braces are trying to solve no longer exists. But more importantly the idea that is trying to be communicated is still valid. You cannot have any other references if you want to have an active mutable reference.

For example the code below gives an error to compile because the mutable reference needs to live beyond the point where the other reference is created.

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;

    let r2 = &mut s;

    println!("{r1}");
}

But curly braces do allow you to control the scope of a variable. For example the code below won't compile because by the time the println comes r1 has been dropped.

    let mut s = String::from("hello");

    {
        let r1 = &mut s;
    } // r1 goes out of scope here and can no longer be used

    println!("{r1}");

[chriskrycho]

Sorry you were confused by this, @jish. @c-git’s explanations here are great! Looking at the book, I am not positive what the best approach here is. Although in this very specific example it does work without the extra block, in many cases introducing a block like that for scope is still useful, so it's handy to have an example of it—and the current example isn’t a great motivation, since a lot of things work more easily or naturally since this was originally written! I am going to leave this open as a question for us to think about whether we want to tweak it a bit.

[maevadevs]

I ended up here after reading some of the contents about the scope of Mutable References in Chapter 4.

I understand about the confusion on the curly braces and new scope question from @jish. If we review the contents in Chapter 3 about Variables and Mutability, then it makes sense. Essentially, each block {} creates a separate scope, thus the 2 mutable reference variables can exist separately from each other in each of their scope.

However, I would recommend in the book to add more details about Mutable Reference Scope. I think that is where the confusion is happening. The only place where it is mentioned is way down, and only as a "by the way" introduction:

Note that a reference’s scope starts from where it is introduced and continues through the last time that reference is used.

As a first time learner, this is a huge shift. It gets very confusing that since chapter 3, my understanding of variables scopes has always been from { to }, only to be told differently up to this point for Mutable Reference scope (or is it for all reference scope, not just mutable ones?). I think this line should be introduced earlier in the paragraph:

Mutable references have one big restriction: if you have a mutable reference to a value, you can have no other references to that value. This code that attempts to create two mutable references to s will fail:...

My change suggestion is as follow:

Mutable references have 2 big restrictions:

1. if you have a mutable reference to a value, you can have no other references to that value until that reference is out of scope.
2. unlike variables that are scoped in a block { }, a reference’s scope starts from where it is introduced and continues through the last time that reference is used or until the end of the block it is within, whichever comes first.
   This code that attempts to create two mutable references to s will fail:...

(Or maybe introduce no. 2 even before this paragraph if it applies to all references, not just mutable reference. Maybe add in the References and Borrowing section instead).

A helpful example of the addition would be the snippet below:

{
        let mut st: String = String::from("hello");

        let mut_r1: &mut String = &mut st; // 1st Mutable Reference
        // let mut_r2: &mut String = &mut st; // 2nd Mutable Reference: Error: Cannot borrow a 2nd time

        println!("{mut_r1}");
        println!("{mut_r1}"); // Last time the 1st Mutable Reference is used within this block. End of scope for mut_r1

        let mut_r2: &mut String = &mut st; // 2nd Mutable Reference: We can now borrow as 1st mutable reference scope has ended
        println!("{mut_r2}");
}