fn main() {
    let mut v = vec![1, 2, 3]; // v created

    let first = &v[0];         // immutable borrow of v begins
    println!("{}", first);     // last use of first — immutable borrow ends HERE (NLL)

    v.push(4);                 // mutable operation on v — OK because immutable borrow ended
    println!("{:?}", v);       // [1, 2, 3, 4]
}                              // v dropped

fn main() {
    let mut v = vec![1, 2, 3];

    let first = &v[0];   // immutable borrow of v
    v.push(4);           // ERROR: mutable borrow while immutable ref exists
    println!("{}", first);
}

fn main() {
    let mut v = vec![1, 2, 3];

    // Option 1: use first before mutating
    let first = v[0]; // copy the value (i32 is Copy)
    v.push(4);
    println!("first: {}, vec: {:?}", first, v);

    // Option 2: restructure so ref ends before push
    {
        let first_ref = &v[0];
        println!("{}", first_ref); // last use — borrow ends here
    }
    v.push(5); // OK now
    println!("{:?}", v);
}

fn main() {
    let s = String::from("hello");
    let s2 = s;              // ownership moves to s2

    println!("{}", s);       // ERROR: s was moved
}

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

    // Option 1: clone if you need two independent copies
    let s2 = s.clone();
    println!("{} and {}", s, s2);

    // Option 2: borrow instead of move
    let s3 = String::from("world");
    let s4 = &s3;           // borrow — s3 still valid
    println!("{} and {}", s3, s4);

    // Option 3: use the value from the new owner
    let s5 = String::from("foo");
    let s6 = s5;            // s5 moved to s6
    println!("{}", s6);     // use s6, not s5
}

fn main() {
    let r;
    {
        let x = 5;
        r = &x;       // r borrows x
    }                 // x is dropped here
    println!("{}", r); // ERROR: r would point to freed memory
}

fn main() {
    // Fix: move x to the same scope as r (or an outer scope)
    let x = 5;       // x declared in outer scope
    let r = &x;      // r borrows x — x lives longer than r
    println!("{}", r); // fine
}

// Common pattern: returning owned data instead of references
fn make_string() -> String {       // return owned String
    let s = String::from("hello");
    s                              // ownership transferred to caller
}

// NOT this (won't compile):
// fn make_ref() -> &String {
//     let s = String::from("hello");
//     &s  // s dropped at end of function — dangling!
// }

fn takes_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let mut s = String::from("hello");
    let r = &s;             // immutable borrow

    takes_ownership(s);     // ERROR: cannot move s while borrowed by r

    println!("{}", r);
}

fn main() {
    let s = String::from("hello");
    let r = &s;
    println!("{}", r);   // last use of r — borrow ends here

    takes_ownership(s);  // OK now — r is no longer in use

    // println!("{}", r); // would be an error — s is gone
}

fn takes_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let mut data = vec![1, 2, 3];

    // Old borrow checker (pre-2018): this would FAIL
    // because r1's borrow would last until end of main()

    // New borrow checker (NLL): this WORKS
    let r1 = &data;
    println!("{:?}", r1);   // r1's last use is here — borrow ends

    data.push(4);           // OK: r1 is already done
    println!("{:?}", data);
}

fn main() {
    let mut map = std::collections::HashMap::new();
    map.insert("a", 1);
    map.insert("b", 2);

    // Problem: holding a reference while trying to insert
    // let val = map.get("a");
    // map.insert("c", 3); // ERROR while val exists
    // println!("{:?}", val);

    // Fix: finish with the reference first
    let has_a = map.contains_key("a"); // returns bool, no reference held
    if has_a {
        map.insert("c", 3); // OK
    }
    println!("{:?}", map);
}

fn process(data: Vec<i32>) -> Vec<i32> {
    data.into_iter().map(|x| x * 2).collect()
}

fn main() {
    let original = vec![1, 2, 3, 4, 5];

    // Without clone: original would be moved and unavailable
    let processed = process(original.clone()); // clone so we keep original

    println!("original: {:?}", original);
    println!("processed: {:?}", processed);
}

fn find_max_index(v: &[i32]) -> usize {
    let mut max_idx = 0;
    for (i, &val) in v.iter().enumerate() {
        if val > v[max_idx] {
            max_idx = i;
        }
    }
    max_idx
}

fn main() {
    let mut nums = vec![3, 1, 4, 1, 5, 9, 2, 6];

    let max_idx = find_max_index(&nums); // get index, not reference
    // Now we're free to mutate
    nums[max_idx] = 0; // zero out the maximum

    println!("{:?}", nums); // [3, 1, 4, 1, 5, 0, 2, 6]
}

use std::collections::HashMap;

fn main() {
    let mut scores: HashMap<String, Vec<i32>> = HashMap::new();

    // PROBLEM: this pattern causes borrow checker errors
    // if !scores.contains_key("Alice") {
    //     scores.insert("Alice".to_string(), vec![]);
    // }
    // scores.get_mut("Alice").unwrap().push(95); // can't: two borrows

    // SOLUTION: use the entry API
    scores
        .entry("Alice".to_string())
        .or_insert_with(Vec::new)
        .push(95);

    scores
        .entry("Alice".to_string())
        .or_insert_with(Vec::new)
        .push(87);

    scores
        .entry("Bob".to_string())
        .or_insert_with(Vec::new)
        .push(78);

    println!("{:?}", scores);
    // {"Alice": [95, 87], "Bob": [78]}
}

use std::cell::RefCell;
use std::rc::Rc;

// A graph node that can have multiple owners and be mutated
struct Node {
    value: i32,
    children: Vec<Rc<RefCell<Node>>>,
}

impl Node {
    fn new(value: i32) -> Rc<RefCell<Node>> {
        Rc::new(RefCell::new(Node {
            value,
            children: vec![],
        }))
    }

    fn add_child(parent: &Rc<RefCell<Node>>, child: Rc<RefCell<Node>>) {
        parent.borrow_mut().children.push(child);
    }
}

fn main() {
    let root = Node::new(1);
    let child1 = Node::new(2);
    let child2 = Node::new(3);

    Node::add_child(&root, child1);
    Node::add_child(&root, child2);

    println!("root value: {}", root.borrow().value);
    println!("children count: {}", root.borrow().children.len());
}

struct Config {
    values: Vec<String>,
    default: String,
}

impl Config {
    fn get_default(&self) -> &str {
        &self.default
    }

    fn add_value(&mut self, v: String) {
        self.values.push(v);
    }
}

fn main() {
    let mut cfg = Config {
        values: vec![],
        default: String::from("none"),
    };

    // Problem: holding reference to cfg.default while mutating cfg
    let d = cfg.get_default(); // borrows all of cfg
    cfg.add_value(String::from("foo")); // ERROR: cfg already borrowed
    println!("{}", d);
}

fn main() {
    let mut cfg = Config {
        values: vec![],
        default: String::from("none"),
    };

    // Fix 1: clone so we own the data, no active borrow
    let d = cfg.get_default().to_string(); // clones the &str into String
    cfg.add_value(String::from("foo"));    // OK: no borrow of cfg exists
    println!("{}", d);

    // Fix 2: reorder — use the reference before mutating
    let mut cfg2 = Config {
        values: vec![],
        default: String::from("none"),
    };
    println!("{}", cfg2.get_default()); // reference used and dropped
    cfg2.add_value(String::from("bar")); // OK now
}