Lifetimes in Rust: mut data borrowed

The following code reports an error：
borrowed value does not live long enough

fn main() {
    let e = 100;
    let mut a = (1,);
    let mut b = (&e,);
    {
        let mut c = (&mut a, &mut b);
        let f = &mut c;
        f.1 .0 = &(f.0 .0);
    }
    println!("{:?}", b);
}

But the following code is correct:

fn main() {
    let e = 100;
    let a = (1,);
    let mut b = (&e,);
    {
        let mut c = (&a, &mut b);
        let f = &mut c;
        f.1 .0 = &(f.0 .0);
    }
    println!("{:?}", b);
}

Why?!!

Full error message for the first code:

error[E0597]: `c` does not live long enough
  --> src/main.rs:7:17
   |
6  |         let mut c = (&mut a, &mut b);
   |             ----- binding `c` declared here
7  |         let f = &mut c;
   |                 ^^^^^^ borrowed value does not live long enough
8  |         f.1 .0 = &f.0 .0;
9  |     }
   |     - `c` dropped here while still borrowed
10 |     println!("{:?}", b);
   |                      - borrow later used here

For more information about this error, try `rustc --explain E0597`.

This is because shared references are Copy, while mutable references are not.

Here's a trimmed down version of your code, which is easier to discuss:

fn main() {
    let mut a = 1;
    let b;
    {
        let mut c = &mut a;
        // Or:
        let mut c = &a;
        let f = &mut c;
        b = &**f;
    }
    println!("{b}");
}

Let's call the lifetimes of a and c 'a and 'c respectively. Therefore, f has type &'c mut &'a [mut] i32. When we do b = &**f, there is a difference between the mutable and immutable version.

In the immutable version, we dereference f to get &'a i32. We then copy this reference (which is fine because shared references are Copy), and get a freestanding reference of type &'a i32. We can assign this reference (or the reborrowed version of it, &*r) to b, because a has the same scope b has.

In the mutable case, we also dereference f. However, the reference we get is a mutable reference: &'a mut i32. Since mutable references are not Copy, we cannot copy it to a freestanding reference. It has to stay where it is, behind the &'c mut of f.

What we can do, however, is to reborrow this reference to create a reference descended from it. However, when you reborrow a reference of type &'a mut &'b mut T, you cannot get a reference of type &'b mut T, only &'a mut T. Otherwise, the reference you got could outlive the original reference, and exist while you have no permission for such reference.

Therefore, we get &'c mut i32, and not &'a mut i32. b outlives c, so we cannot assign a &'c mut i32 (or a shared &'c i32 created from it) to b.