What is borrowing in Rust, and how does it work?

In Rust, borrowing is a core concept that enables other parts of the code to reference or modify data without transferring ownership. This mechanism is a key part of Rust's memory safety guarantees.

Borrowing Mechanics:

1. Immutable Borrowing:
   • When data is immutably borrowed, it can still be read by the borrower but cannot be modified.
   • Within a scope, a data item can have multiple immutable borrows.
   • Example: If we have a Vec<i32> variable named vec, we can perform an immutable borrow like this:

     rust
     let v = &vec;
     ``
     

2. Mutable Borrowing:
   • When data is mutably borrowed, the borrower can modify the data.
   • Within a scope, a data item can have only one mutable borrow.
   • This means that no other borrows (immutable or mutable) can coexist.
   • Example: If we have a Vec<i32> variable named vec, we can perform a mutable borrow like this:

     rust
     let v = &mut vec;
     v.push(5);
     ``

Borrowing Rules:

• Data Races and Concurrency Safety: Rust prevents data races through these borrowing rules. This means that at compile time, Rust ensures the code is safe, preventing issues such as dangling pointers or accessing uninitialized memory that are common in other languages.
• Lifetimes: Every borrow has a lifetime, which is the scope during which the borrow is valid. The Rust compiler ensures all borrows are valid within the lifetime of the borrowed data through lifetime checks.

Practical Application:

Suppose we are writing a function that needs to update some values in a data structure while computing new values based on existing ones. Using mutable borrowing, we can safely modify the data without concern for other parts of the code accidentally modifying it.

rust
fn update_values(values: &mut Vec<i32>) {
    for i in 0..values.len() {
        values[i] += 10;
    }
}

fn main() {
    let mut my_values = vec![1, 2, 3];
    update_values(&mut my_values);
    println!("{:?}", my_values);  // Output: [11, 12, 13]
}

In this example, the update_values function receives a vector via mutable borrowing and updates each element internally. This demonstrates how borrowing enables safe modification of data while maintaining clear code structure and efficient memory usage.