Rust: المراجع والاستعارات في لغة Rust

fn main() {
    let book = String::from("Rust Programming");

    // Multiple immutable references: Multiple people at the same time "read-only" check out
    let reader1 = &book;   // Reader 1 checks out (read-only)
    let reader2 = &book;   // Reader 2 checks out (read-only)
    println!("Readers 1 See: {}", reader1);
    println!("Readers 2 See: {}", reader2);
    // Both references are valid at the same time -- because everyone has read-only access

    let mut notebook = String::from("Notebook");

    // Mutable References: write-only permission
    let writer = &mut notebook;  // Only one person can make changes
    writer.push_str("-- I wrote some notes");
    println!("Rewriter: {}", writer);
    // writer ends scope here, only then can others borrow it again.
}

// ============================================
// Immutable References &T: Multiple readers can borrow items at the same time
// ============================================

fn calculate_length(s: &String) -> usize {
    // s is a String reference, no ownership
    s.len()
}  // s goes out of scope, but since it's a reference, it will not destroy the String

fn main() {
    let s = String::from("Hello, Rust!");

    let len = calculate_length(&s);  // Borrow s, no transfer of ownership
    println!("'{}' The length of is: {}", s, len);  // ✅ s Still available

    // Multiple immutable references can coexist
    let r1 = &s;
    let r2 = &s;
    println!("r1: {}, r2: {}", r1, r2);  // ✅ Read simultaneously
}

'Hello, Rust!' The length of is: 12
r1: Hello, Rust!, r2: Hello, Rust!

// ============================================
// Mutable References &mut T: Only one writer at a time
// ============================================

fn main() {
    let mut s = String::from("Hello");

    // Create a mutable reference
    let r = &mut s;
    r.push_str(", world!");
    println!("Modifying Through a Variable Reference: {}", r);
    // r is used here for the last time, NLL ends

    // After the mutable reference ends, you can create a new mutable reference.
    let r2 = &mut s;
    r2.push_str("!!");
    println!("Another mutable reference: {}", r2);

    // --- Examples of Errors (Uncomment to view compilation errors) ---
    // let mut s2 = String::from("test");
    // let ref1 = &mut s2;
    // let ref2 = &mut s2;  // ❌ There cannot be two mutable references at the same time.
    // println!("{}, {}", ref1, ref2);
}

Modifying Through a Variable Reference: Hello, world!
Another mutable reference: Hello, world!!!

// ============================================
// Demonstration of Conflicts Between Immutable and Mutable References
// ============================================

fn main() {
    let mut data = String::from("Key Data");

    let r1 = &data;       // ✅ Immutable References 1
    let r2 = &data;       // ✅ Immutable References 2
    println!("r1: {}, r2: {}", r1, r2);
    // r1 and r2 are used here for the last time

    let r3 = &mut data;   // ✅ At this point, you can create a mutable reference.
    r3.push_str("--Modified");
    println!("r3: {}", r3);

    // --- Examples of Errors: A mutable reference cannot be created while an immutable reference still exists. ---
    // let mut s = String::from("Demo");
    // let r_a = &s;        // Immutable References
    // let r_b = &mut s;    // ❌ Compilation Error: immutable reference already exists
    // println!("{}, {}", r_a, r_b);
}

r1: Key Data, r2: Key Data
r3: Key Data--Modified

// ============================================
// How Do Compilers Prevent Dangling References?
// ============================================

// Examples of Errors: Return a reference to a local variable
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s  // ❌ Compilation Error: s is destroyed at the end of the function, the reference would be dangling
// }

// The Correct Approach: Return String directly (transfer of ownership)
fn no_dangle() -> String {
    let s = String::from("hello");
    s  // Return String directly, ownership is transferred to the caller
}

fn main() {
    let s = no_dangle();
    println!("Safe Return Values: {}", s);

    // The Correct Way to Reference Local Variables: Use within the scope
    let local = String::from("Local Data");
    let r = &local;          // Quote
    println!("Referencing Local Variables: {}", r);
    // r ends here, local is still valid
}  // local is destroyed here (later than r), safe

Safe Return Values: hello
Referencing Local Variables: Local Data

// ============================================
// Comprehensive Example: Applications of References in Real-Life Scenarios
// ============================================

struct Account {
    owner: String,
    balance: f64,
}

fn check_balance(account: &Account) -> String {
    format!("{} balance: {:.2} yuan", account.owner, account.balance)
}

fn deposit(account: &mut Account, amount: f64) {
    if amount <= 0.0 {
        println!("The deposit amount must be greater than 0");
        return;
    }
    account.balance += amount;
    println!("Deposit {:.2} Yuan Chenggong", amount);
}

fn transfer(from: &mut Account, to: &mut Account, amount: f64) -> bool {
    if amount <= 0.0 || from.balance < amount {
        println!("Transfer Failed: Insufficient balance or invalid amount");
        return false;
    }
    from.balance -= amount;
    to.balance += amount;
    println!("Transfer {:.2} yuan: {} -> {}", amount, from.owner, to.owner);
    true
}

fn show_accounts(accounts: &[Account]) {
    println!("--- Account List ---");
    for (i, acc) in accounts.iter().enumerate() {
        println!("{}. {} balance: {:.2} yuan", i + 1, acc.owner, acc.balance);
    }
}

fn main() {
    let mut alice = Account { owner: String::from("Alice"), balance: 1000.0 };
    let mut bob = Account { owner: String::from("Bob"), balance: 500.0 };

    println!("{}", check_balance(&alice));
    println!("{}", check_balance(&bob));

    deposit(&mut alice, 200.0);
    println!("{}", check_balance(&alice));

    transfer(&mut alice, &mut bob, 300.0)?;

    let accounts = [&alice, &bob];
    show_accounts(&accounts);

    let total: f64 = accounts.iter().map(|a| a.balance).sum();
    println!("Total Deposits: {:.2} yuan", total);
}

Alice balance: 1000.00 yuan
Bob balance: 500.00 yuan
Deposit 200.00 Yuan Successful
Alice balance: 1200.00 yuan
Transfer 300.00 yuan: Alice -> Bob
--- Account List ---
1. Alice balance: 900.00 yuan
2. Bob balance: 800.00 yuan
Total Deposits: 1700.00 yuan