Rust Ownership System Explained (Borrowing and References)

fn main() {
    // Example 1: Stack data (Copy types)
    let x = 5;
    let y = x;  // x is copied (i32 implements Copy trait)
    println!("x: {}, y: {}", x, y);  // Both x and y are valid
    
    // Example 2: Heap data (Move types)
    let s1 = String::from("Hello");
    let s2 = s1;  // s1 is moved to s2 (String doesn't implement Copy)
    
    // println!("{}", s1);  // ❌ Error! s1 is no longer valid
    println!("{}", s2);     // ✅ Only s2 is valid
    
    // Example 3: Function calls also move ownership
    let s3 = String::from("World");
    take_ownership(s3);     // s3 is moved into the function
    // println!("{}", s3);  // ❌ Error! s3 is no longer valid
}

fn take_ownership(some_string: String) {
    println!("{}", some_string);
}  // some_string goes out of scope and is freed

fn main() {
    let s1 = String::from("Hello");
    
    let len = calculate_length(&s1);  // Borrow s1 with &
    
    println!("The length of '{}' is {}.", s1, len);  // s1 still valid!
}

fn calculate_length(s: &String) -> usize {  // s is a reference
    s.len()
}  // s goes out of scope, but it doesn't own the data, so nothing happens

fn main() {
    let mut s = String::from("Hello");  // s must be mutable
    
    change(&mut s);  // Borrow s mutably with &mut
    
    println!("{}", s);  // s has been modified
}

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

fn main() {
    let s = String::from("Hello, World!");
    
    // String slice syntax: [start..end]
    let hello = &s[0..5];    // "Hello"
    let world = &s[7..12];   // "World"
    let whole = &s[..];      // Entire string
    
    println!("hello: {}", hello);
    println!("world: {}", world);
    println!("whole: {}", whole);
    
    // Practical example: finding the first word
    let first = first_word(&s);
    println!("First word: {}", first);
}

fn first_word(s: &String) -> &str {  // Returns a string slice
    let bytes = s.as_bytes();
    
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {  // b' ' is a byte literal for space
            return &s[0..i];
        }
    }
    
    &s[..]  // Return the whole string if no space found
}

fn main() {
    // String literals have type &str (string slice)
    let s = "Hello, World!";  // Type: &str
    
    // This function works with both String and &str
    let len1 = string_length(&String::from("Hello"));  // String
    let len2 = string_length("Hello");                  // &str literal
    
    println!("Lengths: {}, {}", len1, len2);
}

// Best practice: take &str instead of &String for flexibility
fn string_length(s: &str) -> usize {
    s.len()
}

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    
    let slice = &numbers[1..4];  // [2, 3, 4]
    
    println!("Original: {:?}", numbers);
    println!("Slice: {:?}", slice);
    
    // Works with vectors too
    let vec = vec![10, 20, 30, 40, 50];
    let vec_slice = &vec[2..];  // [30, 40, 50]
    
    println!("Vector slice: {:?}", vec_slice);
}

#[derive(Debug)]
struct Transaction {
    from: String,
    to: String,
    amount: u64,
    signature: String,
}

impl Transaction {
    fn new(from: String, to: String, amount: u64) -> Self {
        Transaction {
            from,
            to,
            amount,
            signature: String::from("unsigned"),
        }
    }
    
    fn sign(&mut self, private_key: &str) {
        // Simulate signing process
        self.signature = format!("signed_with_{}", private_key);
    }
    
    fn verify(&self) -> bool {
        // Simulate verification
        !self.signature.starts_with("unsigned")
    }
}

fn main() {
    // Create transaction
    let mut tx = Transaction::new(
        String::from("Alice"),
        String::from("Bob"),
        1000,
    );
    
    println!("Created transaction: {:?}", tx);
    
    // Sign transaction (needs mutable reference)
    sign_transaction(&mut tx, "alice_private_key");
    
    // Verify transaction (immutable reference is fine)
    if verify_transaction(&tx) {
        // Process transaction (ownership transfer)
        process_transaction(tx);
        // tx is no longer accessible here - it was moved
    }
}

fn sign_transaction(tx: &mut Transaction, private_key: &str) {
    tx.sign(private_key);
    println!("Transaction signed");
}

fn verify_transaction(tx: &Transaction) -> bool {
    let is_valid = tx.verify();
    println!("Transaction valid: {}", is_valid);
    is_valid
}

fn process_transaction(tx: Transaction) {  // Takes ownership
    println!("Processing transaction: {:?}", tx);
    // Transaction is consumed here
}

#[derive(Debug, Clone)]
struct Account {
    address: String,
    balance: u64,
    nonce: u32,
}

impl Account {
    fn new(address: String, initial_balance: u64) -> Self {
        Account {
            address,
            balance: initial_balance,
            nonce: 0,
        }
    }
    
    fn transfer(&mut self, amount: u64) -> Result<(), String> {
        if self.balance >= amount {
            self.balance -= amount;
            self.nonce += 1;
            Ok(())
        } else {
            Err("Insufficient funds".to_string())
        }
    }
    
    fn receive(&mut self, amount: u64) {
        self.balance += amount;
    }
}

fn main() {
    let mut alice = Account::new("Alice123".to_string(), 5000);
    let mut bob = Account::new("Bob456".to_string(), 1000);
    
    println!("Initial state:");
    print_account_summary(&alice);
    print_account_summary(&bob);
    
    // Transfer funds
    let transfer_amount = 1500;
    match execute_transfer(&mut alice, &mut bob, transfer_amount) {
        Ok(()) => println!("Transfer successful!"),
        Err(e) => println!("Transfer failed: {}", e),
    }
    
    println!("\nFinal state:");
    print_account_summary(&alice);
    print_account_summary(&bob);
}

fn execute_transfer(
    from: &mut Account, 
    to: &mut Account, 
    amount: u64
) -> Result<(), String> {
    from.transfer(amount)?;  // ? operator propagates errors
    to.receive(amount);
    Ok(())
}

fn print_account_summary(account: &Account) {
    println!("{}: Balance={}, Nonce={}", 
             account.address, account.balance, account.nonce);
}