RUST: Ownership & Borrowing

fn main() {
    // --- Ownership ---

    // 1. Move: When a value is assigned to a new variable, ownership is transferred.
    let s1 = String::from("hello");
    let s2 = s1; // s1's ownership is moved to s2. s1 is no longer valid.
    // println!("s1: {}", s1); // This would cause a compile-time error because s1 is no longer valid.
    println!("s2: {}", s2); // s2 is valid and owns the string "hello".

    // 2. Copy: For types that implement the Copy trait (e.g., integers, booleans, characters),
    // a copy is made instead of a move. Both variables are valid.
    let x = 5;
    let y = x; // x is copied to y.
    println!("x: {}, y: {}", x, y); // Both x and y are valid.

    // 3. Function Ownership Transfer: When passing a variable to a function, ownership is moved.
    let s3 = String::from("world");
    takes_ownership(s3); // s3's ownership is moved to the function.
    // println!("s3: {}", s3); // This would cause a compile-time error because s3 is no longer valid.

    // 4. Returning Ownership: Functions can return ownership of a value.
    let s4 = gives_ownership(); // The function returns ownership of a String.
    println!("s4: {}", s4);

    let s5 = String::from("hello again");
    let s6 = takes_and_gives_back(s5); // Ownership is moved to the function and then returned.
    println!("s6: {}", s6);

    // --- Borrowing ---

    // 5. Immutable Borrowing: Allows multiple read-only references to a value.
    let s7 = String::from("borrowed");
    let len1 = calculate_length(&s7); // Immutable borrow of s7.
    let len2 = calculate_length(&s7); // Another immutable borrow of s7.
    println!("The length of '{}' is {} and {}", s7, len1, len2); // s7 is still valid.

    // 6. Mutable Borrowing: Allows one mutable reference to a value.
    let mut s8 = String::from("mutable");
    change(&mut s8); // Mutable borrow of s8.
    println!("s8: {}", s8); // s8 has been modified.

    // 7. Restrictions on Mutable Borrowing: Only one mutable borrow is allowed at a time.
    let mut s9 = String::from("multiple mutable");
    // let r1 = &mut s9; // First mutable borrow.
    // let r2 = &mut s9; // Second mutable borrow - compile-time error!
    // println!("{}, {}", r1, r2);

    // 8. Mixing Immutable and Mutable Borrows: You cannot have a mutable borrow while there are immutable borrows.
    let mut s10 = String::from("mixed borrows");
    let r3 = &s10; // Immutable borrow.
    // let r4 = &mut s10; // Mutable borrow - compile-time error!
    println!("r3: {}", r3);
    let r4 = &mut s10;
    println!("r4: {}", r4);

    // 9. Dangling References: The compiler prevents dangling references.
    // let reference_to_nothing = dangle(); // This would cause a compile-time error.
}

fn takes_ownership(some_string: String) {
    println!("takes_ownership: {}", some_string);
} // Here, some_string goes out of scope and `drop` is called. The backing memory is freed.

fn gives_ownership() -> String {
    let some_string = String::from("hello from gives_ownership");
    some_string // Ownership is moved out of the function.
}

fn takes_and_gives_back(a_string: String) -> String {
    a_string // Ownership is moved out of the function.
}

fn calculate_length(s: &String) -> usize {
    s.len()
} // Here, s goes out of scope. But because it does not have ownership of what it refers to, nothing happens.

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

// fn dangle() -> &String { // dangle returns a reference to a String
//     let s = String::from("hello"); // s is a new String
//     &s // we return a reference to the String, s
// } // Here, s goes out of scope, and is dropped. Its memory goes away.
//   // Danger!