De-sugaring Rust's Reference

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}
fn main() {
    // Topic: Reference Operators
    // Dot operator is the only exception that doesn't need to explicitly use & and * for borrowing and dereferencing.
    let bx  = &MyBox::new(5);
    assert_eq!(5, bx.0);
    // Equivalent to the above, but with the dereference written out
    assert_eq!(5, (*bx).0);
    let v  = vec![1, 2, 3];
    v.len(); // implicitly borrows a reference to v
    (&v).len(); // equivalent, but more verbose
}

    let ss = String::from("hello");
    // ss1 type: &String
    let ss1 =&ss;
    // deref coercion: conceptually equivalent to ss.deref(); 
    // the call ss.deref() is effectively treated as (&ss).deref() where ss is implicitly borrowed
    let ss2: &str = &ss;

    // conceptually equivalent to &*(ss.deref()); ss3 type: &str
    let ss3 = &*ss;
    // another way to get the string slice from the String. ss4 type: &str
    let ss4 = &ss[..];

impl<T> Deref for MyBox<T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

fn main() {
    ...
    // bx: &MyBox<i32>; *bx: MyBox<i32>; **bx: *MyBox<i32> = *(&Target) = i32
    assert_eq!(5, **bx);
}

    // let mut b = 1; let x = &b; x is an immutable reference; x itself is immutable, i.e. x cannot refer to other objects.
    // let mut b = 1; let mut x = &b; x is an immutable reference; x itself is mutable, i.e. x can refer to other objects.
    // let x = &mut b; x is a mutable reference; x itself is immutable.
    // let mut x = &mut b; x is a mutable reference; x itself is mutable.e.g.
    let mut b = 1_000_i32;
    let mut c = 3_000_i32;
    let mut x = &mut b;
    *x = 2_000;
    x = &mut c;
    *x = 4_000;
    // 2000, 4000
    println!("{}, {}", b, c);

    // Topic: Reborrow
    let mut w = 32;
    // x, y, z type is the same: &mut i32
    let x = &mut w;
    // Reborrowing: equivalent to let y = &mut *x; let z = &mut *x;
    // On the surface, the safety is suspectible because both x, y and z hold exclusive access to w.
    // It's safe because you can't use the original borrow until the reborrow is over.
    // Explicitly specify the type otherwise let y=x will move x to y as mutable reference is not a Copy.
    let y: &mut _ = x;
    let z: &mut i32 = y;
    // The code below won't compile: cannot borrow `*y` as mutable more than once at a time.
    // println!("{}", (&mut *y));
    // The code below won't compile, demonstrating that z's reborrowing is safe.
    // *y = 2; println!("{}", y);
    *z = 2;
    // z is over. Thus we can either use y e.g., *y=4 or reborrow again;
    println!("{}", (&mut *y));
    // y is over. Thus we can use the original borrow x again;
    *x = 4;
    // c type: FnMut
    // the closure c's x is a reborrow of outer x; 
    // The `mut` is required on `c` because a `&mut` is stored inside.
    let mut c = || {
        *x = 8;
    };
    c();
    // d type: FnOnce
    // the closure d move the mutable reference x
    let d = || {
        let u = x;
    };
    d();
    // The code below won't compile because both x and d are moved.
    // *x = 2;
    // d();

    // Topic: Smart Pointer
    // sort of C++ unique_ptr
    let mut r = Box::new(String::from("hello"));
    r.push_str("world");
    println!("{}", r);

    // sort of C++ shared_ptr
    // Rc is immutable: let r = Rc:new("hello".to_string()); r.push_str() is invalid
    // Interior Mutability: RefCell is immutable too but allows to change the internal data
    let r = Rc::new(RefCell::new(String::from("hello")));
    let r2 = Rc::clone(&r);
    {
        // rf type: RefMut<'_, String>; need to add the modifier mut for rf to invoke write methods, which is a little bit different than the normal mutable reference.
        let mut rf = r.borrow_mut();
        rf.push_str(" world");
        // rf2 type: &mut String; reborrowing
        let rf2 = &mut *rf;
        rf2.push_str(" world2");
        println!("{}", rf)
    }
    // let rf3 = r.borrow_mut(); rf3.push_str(" world3"); Will panic at runtime as the rf3 is still alive. However, the separated statements of creation and modification work for the normal mutable reference in terms of the reborrowing rule. 
    // Such nuance is caused by the inherent difference of the rule check mechanism between RefCell and the normal mutable reference. 
    // That's the reason why we add curly brackets around the previous block for rf and rf2 manipulation.
    // If we borrow_mut and push_str in the same statement, it's safe because the temporal output of borrow_mut is over after the statement.
    r.borrow_mut().push_str(" world3");
    println!("{}", r.borrow());
    println!("{}", r2.borrow());

    // &x won't work because cannot move out of non-copiable element
    // Expression let &e = &String::from("hello") is invalid with the same reason
    // x type: &String;
    for x in &a {
        println!("Iterator Produce shared reference; {}", x)
    }

    // x type: &&String
    for ref x in a.iter() {
        let s = x;
        // auto deref in succesion.
        println!("borrow a reference to the match value whose type is a shared reference: {}", s)
    }

    let mut vect = vec![1, 2, 3];
    // item type: i32, which is the copy of element.
    // A valid example with same essense: let &c = &5; the type of variable c is i32. Copy Trait
    for &item in &vect {
        println!("Match the type of mutable reference: {}", item);
    }
    // the enumerate() prouduce the tuple (index, &mut T)
    // when matching a reference, you can't move a value out of a reference, even a mut reference
    // use a ref pattern to borrow a reference to a part. Actually equivalent to for (_, item) in ...
    // item type: &mut i32
    for &mut ref mut item in &mut vect {
        *item = 2 * (*item);
    }
    // item type: &i32
    for (i, item) in vect.iter().enumerate() {
        println!("Change item via mutable refereance; {} {}", i, *item)
    }