[SOLVED] How borrow as mutable vs immutable in Rust?

How borrow as mutable vs immutable in Rust?

I've read these docs: https://doc.rust-lang.org/rust-by-example/scope/borrow/mut.html

I've also read this question: (Cannot borrow immutable borrowed content as mutable)

The docs helped me understand how to declare borrowing as mutable (I think):

let mut (part1, part2) = someTuple;

But I'm haven't been able to find explicit instructions on what borrowing as an immutable looks like. This is my guess:

let (part1, part2) = someTuple;

I know this is a super basic question, but Googling it took me way off into the deep end of explanations and I'm still trying to get my bearings in the most simple of contexts.

How do I borrow as mutable vs an immutable in Rust?

Solution

let x = 0;
let immutable_borrow = &x; //borrow as immutable

//to borrow as mutable the variable needs to be declared as mutable
let mut y = 1;
let mutable_borrow = &mut y; //borrow as mutable

Note 1: you can borrow a variable either as immutable or mutable in the same scope, meaning you can't do this:

let mut x = 0;
let immutable_borrow = &x;
let mutable_borrow = &mut x;

Why?

Because if you would have mutable and immutable references of the same variable, then the data of that variable could change through that mutable reference and that could cause a lot of problems.

Note 2: you can immutably borrow a variable endless times but you can mutably borrow a variable only once.

//You can do this
let x = 0;
let x1 = &x;
let x2 = &x;
//...

//But you can't do this
let mut y = 0;
let y1 = &mut y;
let y2 = &mut y; //won't compile if you use y1 after you declare y2

Why?

As mentioned above. One mutable reference could change the data all the other mutable references are poiting to without them knowing. That could cause a lot of problems. But having multiple immutable references is okay, because the data can't be unexpectedly changed.