Code from http://arthurtw.github.io/2014/11/30/rust-borrow-lifetimes.html in a version that works with modern Rust (2018).

example1.rs

#![allow(unused_variables, unused_assignments, unused_mut)]

use std::boxed::Box;

struct Foo {
    f: Box<i32>,
}

// Owner cannot access resource during a mutable borrow - 1
fn main() {
    let mut a = Foo { f: Box::new(0) };
    // mutable borrow
    let x = &mut a;
    // error: cannot borrow `a.f` as immutable because `a` is also borrowed as mutable
    //println!("{}", a.f);
}

example2.rs

use std::boxed::Box;

#[derive(Debug)]
struct Foo {
    f: Box<i32>,
}

// Owner cannot access resource during a mutable borrow - 2
fn main() {
    let mut a = Foo { f: Box::new(0) };
    {
        // mutable borrow
        let x = &mut a;
        println!("{:?}", x);
        // mutable borrow ends here
    }
    println!("{}", a.f);
}

example3.rs

#![allow(unused_variables, unused_assignments, unused_mut)]

use std::boxed::Box;

struct Foo {
    f: Box<i32>,
}

// Borrower can move the mutable borrow to a new borrower
fn main() {
    let mut a = Foo { f: Box::new(0) };
    // mutable borrow
    let x = &mut a;
    // move the mutable borrow to new borrower y
    let y = x;
    // error: use of moved value: `x.f`
    //println!("{}", x.f);
}

example4.rs

#![allow(unused_variables, unused_assignments, unused_mut)]

use std::boxed::Box;

#[derive(Debug)]
struct Foo {
    f: Box<i32>,
}

// Borrow formula
fn main() {
    let mut a = Foo { f: Box::new(0) };
    let y: &Foo;
    if false {
        // borrow
        let x = &a;
        // share the borrow with new borrower y, hence extend the borrow scope
        y = x;
    }
    // error: cannot assign to `a.f` because it is borrowed
    // a.f = Box::new(1);
}

example5.rs

#![allow(unused_variables, unused_assignments, unused_mut)]

use std::boxed::Box;

struct Foo {
    f: Box<i32>,
}

fn max<'a>(x: &'a Foo, y: &'a Foo) -> &'a Foo {
    if x.f > y.f { x } else { y }
}

// Named borrow scope
fn main() {
    let a = Foo { f: Box::new(1) };
    let y: &Foo;
    if false {
        let b = Foo { f: Box::new(0) };
        let x = max(&a, &b);
        // error: `b` does not live long enough
        // y = x;
    }
}

example6.rs

#![allow(unused_variables, unused_assignments, unused_mut, dead_code)]

use std::boxed::Box;

struct Foo {
    f: Box<i32>,
}

struct Link<'a> {
    link: &'a Foo,
}

// Struct to borrow multiple resources
fn main() {
    let a = Foo { f: Box::new(0) };
    let mut x = Link { link: &a };
    if false {
        let b = Foo { f: Box::new(1) };
        // error: `b` does not live long enough
        // x.link = &b;
    }
}

example7.rs

#![allow(unused_variables, unused_assignments, unused_mut, dead_code)]

use std::boxed::Box;

struct Foo {
    f: Box<i32>,
}

struct Link<'a> {
    link: &'a Foo,
}

fn store_foo<'a>(x: &mut Link<'a>, y: &'a Foo) {
    x.link = y;
}

// Function to extend borrow scope without a return value
fn main() {
    let a = Foo { f: Box::new(0) };
    let x = &mut Link { link: &a };
    if false {
        let b = Foo { f: Box::new(1) };
        // store_foo(x, &b);
    }
}