Rusty Rules: Understanding Rust's Borrow Checker

Rust is a programming language that prides itself on being fast, safe, and reliable. One of the ways Rust ensures safety is through its borrow checker. But what exactly is the borrow checker, and how does it work? In this blog, we'll explore Rust's borrow checker rules, using simple analogies. This is the continuation of my previous blog post where I discussed the high-level overview of borrow checker.

Ownership: The Boss

To understand the borrow checker, we first need to understand ownership in Rust. In Rust, every value has an owner. The owner is like a boss who controls the value and the memory it occupies. When the owner goes out of scope, Rust frees the memory associated with it, preventing memory leaks.

This means that when a value is assigned to a new variable, the ownership of the value is transferred to the new variable and the old variable cannot be used to access that value anymore.

Think of it like a landlord who owns an apartment. When the lease is up, the landlord takes back the keys, and the apartment is no longer accessible.

Moving In: Transfer of Ownership

Ownership can be transferred from one owner to another using the move semantics. When you assign a value to a new variable, you're transferring the ownership from the previous owner to the new owner. The old owner can no longer access the value.

It's like giving your apartment keys to a new tenant. Once they have the keys, you can no longer enter the apartment.

Borrowing: Sharing is Caring

Borrowing, on the other hand, is when you give temporary access to a value to another variable without transferring ownership.

Think of it like lending your apartment keys to a friend. They can use the apartment, but they don't own it. In Rust, you can create references to a value, which allows borrowing. References are like photocopies of the apartment keys. Your friend can use the apartment, but they can't make any changes to it.

Rust's Rules: Keeping Borrowing in Check

Now that we understand ownership and borrowing let's take a look at Rust's set of borrowing rules:

• Each value in Rust has a variable that is its owner.

fn main() {
    let x = 5; // x is the owner of the value 5
    println!("The value of x is: {}", x);
}

• There can only be one mutable reference to a variable at a time.

let mut x = 5;
let y = &mut x;
let z = &mut x; // error: cannot borrow `x` as mutable more than once at a time

• There can be multiple immutable references to a variable at a time.

let x = vec![1, 2, 3];
let y = &x; // First immutable reference
let z = &x; // Second immutable reference (valid)

• References must always be valid. Rust will not allow a reference to a variable that has gone out of scope.

fn main() {
    let reference_to_nothing = dangling_reference();
    println!("This will not print: {}", reference_to_nothing);
}

fn dangling_reference() -> &String {
    let s = String::from("Hello, world!");
    &s
}

• Variables cannot be borrowed as mutable and immutable at the same time.

fn main() {
    let mut x = 5;
    let y = &x;
    let w = &x; // valid 
    let z = &mut x; // error: cannot borrow `x` as mutable because it is also borrowed as immutable
}

This rule makes sense because if a variable has both mutable and immutable references, there is a possibility that the mutable reference could change the value of the variable, while the immutable reference is still pointing to the previous value. This could lead to unexpected behavior and errors in the code.

Thanks for reading!