Non-lexical lifetimes - rust

Question

Can someone explain the following, please?
this compiles (explanation: NLL y not referenced after initial definition?)
fn main() {
let mut x = 5;
let y = &x;
let z = &mut x;
println!("z: {}", z);
}
this doesn't compile (explanation: z not referenced but only introduced the line before so still active?)
fn main() {
let mut x = 5;
let y = &x;
let z = &mut x;
println!("y: {}", y);
}
this compiles (explanation: NLL z not referenced after initial definition?)
fn main() {
let mut x = 5;
let z = &mut x;
let y = &x;
println!("y: {}", y);
}
this doesn't compile (just to see whether introducing lines would lead to z not being active by the println)
fn main() {
let mut x = 5;
let y = &x;
let z = &mut x;
let foo = String::from("foo");
println!("y: {}, foo: {}", y, foo);
}
I'm confused... I couldn't find anything that covers this specific case in the book but if somebody has a link to something that explains this behaviour, I would appreciate it.

Answer 1

fn main() {
let mut x = 5;
let y = &x;
// 'y lifetime starts, holding an immutable reference to x
// 'y lifetime ends (never used later), releasing hold on x
let z = &mut x; // this is fine because the hold is released
println!("z: {}", z);
}
fn main() {
let mut x = 5;
let y = &x;
// 'y lifetime starts, holding an immutable reference to x
let z = &mut x; // this is forbidden because of the existing hold
println!("y: {}", y);
// 'y lifetime ends, releasing hold on x
}
fn main() {
let mut x = 5;
let z = &mut x;
// 'z lifetime starts, holding a mutable reference to x
// 'z lifetime ends (never used later), releasing hold on x
let y = &x; // this is fine because the hold is released
println!("y: {}", y);
// 'y lifetime ends, releasing hold on x
}
Pretty much the same as #2
fn main() {
let mut x = 5;
let y = &x;
// 'y lifetime starts, holding an immutable reference to x
let z = &mut x; // this is forbidden because of the existing hold
let foo = String::from("foo");
println!("y: {}, foo: {}", y, foo);
// 'y lifetime ends, releasing hold on x
}
As you know, no other references can exist while a mutable reference to some data also exists. You will see &mut also called "exclusive references" for this reason.
The borrow checker is what enforces this, using the lifetimes of the references in your code. In older versions of Rust, all lifetimes were "lexical" - they would last as long as their containing scope. "Non-lexical lifetimes" were introduced to make things easier for the programmer, by making it so reference lifetimes would only last as long as those references were used.
This is what allows examples #1 and #3 to work. A reference is created but the lifetime immediately ends because they aren't used later, so there is no overlap of lifetimes when the next line creates a different reference.

Answer 2

It's useful to look at the lifetime of every variable here. Let's look example by example.
// example one
fn main() {
let mut x = 5;
let y = &x; // y is declared here, but never used
// so its lifetime is effectively nil
let z = &mut x; // by this line, it no longer exists
println!("z: {}", z);
}
// example two
fn main() {
let mut x = 5;
let y = &x; // y is declared here and used in the
// println, so...
let z = &mut x; // ...this is invalid, since you cannot
// take a mutable reference when you have
// an existing reference.
println!("y: {}", y);
}
// example three
fn main() {
let mut x = 5;
let z = &mut x; // z is declared here but never used
// so its lifetime is effectively nil
let y = &x; // by this line, it no longer exists
println!("y: {}", y);
}
// example four
fn main() {
let mut x = 5;
let y = &x;
let z = &mut x; // This is functionally identical to ex. 2
let foo = String::from("foo");
println!("y: {}, foo: {}", y, foo);
}