Restructuring Patterns

fn bump_first(v: &mut Vec<u32>) {
    // let first = &v[0];        // shared borrow...
    // v.push(*first + 1);       // E0502: ...still used by the argument
    let first = v[0];            // u32 is Copy: no borrow survives the statement
    v.push(first + 1);
}

fn log_len_then_clear(names: &mut Vec<String>) {
    let n = names.len();         // read what you need first
    names.clear();
    println!("cleared {n} names");
}

#[derive(Debug, Clone)]
struct Job { id: u32, retries: u32, failed: bool }

fn schedule_retries(jobs: &mut Vec<Job>) {
    // for j in jobs.iter() { if j.failed { jobs.push(..) } }   // E0502
    let retries: Vec<Job> = jobs
        .iter()
        .filter(|j| j.failed && j.retries < 3)
        .map(|j| Job { id: j.id, retries: j.retries + 1, failed: false })
        .collect();
    jobs.retain(|j| !j.failed);
    jobs.extend(retries);
}

fn split_expired(sessions: &mut Vec<(u64, String)>, now: u64) -> Vec<(u64, String)> {
    let mut expired = Vec::new();
    sessions.retain(|s| {
        if s.0 < now { expired.push(s.clone()); false } else { true }
    });
    expired
}

#[derive(Debug)]
struct Account { balance: i64 }

fn transfer(accts: &mut [Account], from: usize, to: usize, amount: i64) {
    // let a = &mut accts[from]; let b = &mut accts[to];   // E0499
    assert_ne!(from, to, "transfer to self");
    let (a, b) = if from < to {
        let (lo, hi) = accts.split_at_mut(to);
        (&mut lo[from], &mut hi[0])
    } else {
        let (lo, hi) = accts.split_at_mut(from);
        (&mut hi[0], &mut lo[to])
    };
    a.balance -= amount;
    b.balance += amount;
}

struct Renderer { frames: Vec<String>, stats: Stats }
#[derive(Default)]
struct Stats { drawn: u32 }

impl Stats {
    fn record(&mut self) { self.drawn += 1; }
}

impl Renderer {
    fn draw_all(&mut self) {
        // for f in &self.frames { self.record_frame(f) }   // E0502 if record_frame takes &mut self
        let stats = &mut self.stats;                         // borrow the field, not self
        for frame in &self.frames {
            let _ = frame.len();
            stats.record();
        }
    }
}

use std::collections::HashMap;

fn count_words(text: &str) -> HashMap<&str, usize> {
    let mut counts = HashMap::new();
    for w in text.split_whitespace() {
        *counts.entry(w).or_insert(0) += 1;
    }
    counts
}

fn cache_get<'m>(cache: &'m mut HashMap<u64, Vec<u8>>, key: u64, load: impl FnOnce() -> Vec<u8>) -> &'m mut Vec<u8> {
    // if let Some(v) = cache.get_mut(&key) { return v; }   // E0499 (NLL problem case #3)
    // cache.insert(key, load()); cache.get_mut(&key).unwrap()
    cache.entry(key).or_insert_with(load)
}

use std::mem;

struct Batcher { pending: Vec<String>, last_error: Option<String> }

impl Batcher {
    fn flush(&mut self) -> Vec<String> { mem::take(&mut self.pending) }
    fn error(&mut self) -> Option<String> { self.last_error.take() }
}

use std::mem;

enum Conn {
    Idle,
    Connecting { attempts: u32 },
    Open { session: String },
    Closed,
}

struct Client { state: Conn }

impl Client {
    fn on_connected(&mut self, session: String) {
        self.state = match mem::replace(&mut self.state, Conn::Closed) {
            Conn::Connecting { .. } => Conn::Open { session },
            other => other, // unexpected event: keep the old state
        };
    }
    fn retry(&mut self) {
        if let Conn::Connecting { attempts } = &mut self.state {
            *attempts += 1;                  // in-place change: a `&mut` binding is enough
        } else if matches!(self.state, Conn::Idle) {
            self.state = Conn::Connecting { attempts: 1 };
        }
    }
}

struct Library { books: Vec<Book>, loans: Vec<Loan> }
struct Book { title: String, available: bool }
struct Loan { book: usize, member: String } // index into `books`, not &Book

impl Library {
    fn lend(&mut self, book: usize, member: &str) -> Result<(), String> {
        let b = self.books.get_mut(book).ok_or("no such book")?;
        if !b.available { return Err(format!("{} is out", b.title)); }
        b.available = false;
        self.loans.push(Loan { book, member: member.to_owned() });
        Ok(())
    }
}

#[derive(Debug)]
struct Node { name: String, parent: Option<usize>, children: Vec<usize> }

#[derive(Default)]
struct Tree { nodes: Vec<Node> }

impl Tree {
    fn add(&mut self, name: &str, parent: Option<usize>) -> usize {
        let id = self.nodes.len();
        self.nodes.push(Node { name: name.into(), parent, children: Vec::new() });
        if let Some(p) = parent {
            self.nodes[p].children.push(id);
        }
        id
    }
    fn path(&self, mut id: usize) -> Vec<&str> {
        let mut out = vec![self.nodes[id].name.as_str()];
        while let Some(p) = self.nodes[id].parent {
            out.push(&self.nodes[p].name);
            id = p;
        }
        out.reverse();
        out
    }
}

struct Doc { text: String, words: Vec<std::ops::Range<usize>> }

impl Doc {
    fn new(text: String) -> Self {
        let mut words = Vec::new();
        let mut start = None;
        for (i, ch) in text.char_indices() {
            match (ch.is_whitespace(), start) {
                (false, None) => start = Some(i),
                (true, Some(s)) => { words.push(s..i); start = None; }
                _ => {}
            }
        }
        if let Some(s) = start { words.push(s..text.len()); }
        Doc { text, words }
    }
    fn word(&self, n: usize) -> Option<&str> { self.words.get(n).map(|r| &self.text[r.clone()]) }
}

use std::collections::VecDeque;

fn mark_reachable(edges: &[Vec<usize>], start: usize) -> Vec<bool> {
    let mut seen = vec![false; edges.len()];
    let mut queue = VecDeque::from([start]);
    while let Some(n) = queue.pop_front() {
        if std::mem::replace(&mut seen[n], true) { continue; }
        queue.extend(edges[n].iter().copied().filter(|&m| !seen[m]));
    }
    seen
}