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

    let len = calculate_length(s); // ownership moves here

    // s is no longer valid — we can't use it!
    // println!("{}", s); // ERROR: value borrowed here after move
    println!("Length: {}", len);
}

fn calculate_length(s: String) -> usize {
    s.len()
} // s is dropped here

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

    // Transfer ownership in, get it back out
    let (s, len) = calculate_length(s);

    println!("'{}' has length {}", s, len); // now we can use s again
}

fn calculate_length(s: String) -> (String, usize) {
    let len = s.len();
    (s, len) // return ownership back to caller
}

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

    let len = calculate_length(&s); // pass a reference — not ownership

    println!("'{}' has length {}", s, len); // s still valid!
}

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

fn main() {
    let s = String::from("hello");
    let r = &s; // r is an immutable reference to s

    println!("{}", r);       // fine — reading is allowed
    println!("{}", s);       // also fine — s is still the owner

    // r.push_str("!"); // ERROR: cannot borrow as mutable
    // *r = String::from("world"); // ERROR: cannot assign through &String
}

fn greet(name: &String) {       // accepts a reference to String
    println!("Hello, {}!", name);
}

fn main() {
    let name = String::from("Alice");

    greet(&name);   // borrow name — pass a reference
    greet(&name);   // borrow again — still valid!
    greet(&name);   // and again — immutable refs can be reused freely

    println!("name is still: {}", name); // ownership never left main
}

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

    let r1 = &s; // first reference
    let r2 = &s; // second reference
    let r3 = &s; // third reference — all fine!

    println!("{}, {}, {}", r1, r2, r3); // all valid simultaneously
}

fn main() {
    let s = String::from("hello"); // s owns the String

    {
        let r = &s;              // r borrows s
        println!("{}", r);       // use r
    }                            // r goes out of scope — String is NOT dropped
                                 // (r didn't own it)

    println!("{}", s);           // s still valid — it's still the owner
}                                // s goes out of scope — String IS dropped here

fn main() {
    let x = 5;
    let r = &x;             // r is a reference to x

    println!("{}", r);      // Rust auto-derefs — prints 5
    println!("{}", *r);     // explicit deref — also prints 5

    // Comparison works with auto-deref
    if *r == 5 {
        println!("r points to 5");
    }

    // Auto-deref in method calls
    let s = String::from("hello");
    let sr = &s;
    println!("{}", sr.len()); // same as (*sr).len() — auto-deref
}

// This does NOT compile in Rust
fn dangle() -> &String {         // trying to return a reference
    let s = String::from("hello"); // s is created here
    &s                           // try to return a reference to s
}                                // s is dropped here — reference would dangle!

fn no_dangle() -> String {
    let s = String::from("hello");
    s            // move ownership out — caller takes responsibility for cleanup
}

fn main() {
    let s = no_dangle();
    println!("{}", s); // perfectly safe
}

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];    // slice: bytes 0–4 → "hello"
    let world = &s[6..11];   // slice: bytes 6–10 → "world"

    println!("{} {}", hello, world); // hello world

    // String literals are already slices (&str)
    let literal: &str = "I am a string slice";

    // Vector slices
    let v = vec![1, 2, 3, 4, 5];
    let first_three: &[i32] = &v[0..3];
    println!("{:?}", first_three); // [1, 2, 3]
}

// Flexible: accepts both &str and &String (via deref coercion)
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &byte) in bytes.iter().enumerate() {
        if byte == b' ' {
            return &s[0..i]; // return slice up to first space
        }
    }
    &s[..] // no space found — return whole string
}

fn main() {
    let owned = String::from("hello world");
    let literal = "hello world";

    println!("{}", first_word(&owned));   // &String — works via deref coercion
    println!("{}", first_word(literal));  // &str — works directly
    println!("{}", first_word(&owned[6..])); // slice of String — also works
}

fn main() {
    let r;                   // r declared — no value yet

    {
        let x = 5;
        r = &x;              // r borrows x
        println!("{}", r);   // OK — x is still alive here
    }                        // x is dropped here

    // println!("{}", r);    // ERROR — r would outlive x!
}