Shared Ownership and Interior Mutability

use std::borrow::Cow;

fn normalize_ws(s: &str) -> Cow<'_, str> {
    if s.contains('\t') {
        Cow::Owned(s.replace('\t', "    "))
    } else {
        Cow::Borrowed(s)
    }
}

fn main() {
    let a = normalize_ws("plain");
    let b = normalize_ws("a\tb");
    assert!(matches!(a, Cow::Borrowed(_)));
    assert_eq!(b, "a    b");
}

use std::sync::Arc;
use std::thread;

struct Config { region: String, retries: u32 }

fn main() {
    let cfg = Arc::new(Config { region: "eu-west-1".into(), retries: 3 });
    let handles: Vec<_> = (0..4)
        .map(|i| {
            let cfg = Arc::clone(&cfg); // clone the handle, not the Config
            thread::spawn(move || format!("worker {i} in {} ({} retries)", cfg.region, cfg.retries))
        })
        .collect();
    for h in handles {
        println!("{}", h.join().unwrap());
    }
}

use std::rc::Rc;

fn main() {
    let mut a = Rc::new(vec![1, 2, 3]);
    let b = Rc::clone(&a);
    Rc::make_mut(&mut a).push(4);       // `a` is shared, so its Vec is cloned first
    assert_eq!(*a, vec![1, 2, 3, 4]);
    assert_eq!(*b, vec![1, 2, 3]);      // `b` still sees the original
}

use std::cell::Cell;

struct Counter { hits: Cell<u64> }

impl Counter {
    fn hit(&self) { self.hits.set(self.hits.get() + 1); } // mutation through &self
}

fn main() {
    let c = Counter { hits: Cell::new(0) };
    c.hit();
    c.hit();
    assert_eq!(c.hits.get(), 2);
}

use std::cell::RefCell;

struct Registry { names: RefCell<Vec<String>> }

impl Registry {
    fn add(&self, n: &str) { self.names.borrow_mut().push(n.to_owned()); }

    fn add_all_upper(&self) {
        // for n in self.names.borrow().iter() { self.add(&n.to_uppercase()); } // panics: BorrowMutError
        let upper: Vec<String> = self.names.borrow().iter().map(|n| n.to_uppercase()).collect(); // Ref dropped here
        for n in upper {
            self.add(&n);
        }
    }

    fn try_add(&self, n: &str) -> bool {
        match self.names.try_borrow_mut() {     // no panic: report or defer instead
            Ok(mut v) => { v.push(n.to_owned()); true }
            Err(_) => false,
        }
    }
}

fn main() {
    let r = Registry { names: RefCell::new(vec!["a".into()]) };
    r.add_all_upper();
    assert!(r.try_add("b"));
    assert_eq!(r.names.borrow().len(), 3);
}

use std::sync::{Arc, Mutex, PoisonError};
use std::thread;

fn main() {
    let totals = Arc::new(Mutex::new(Vec::new()));
    let hs: Vec<_> = (0..4)
        .map(|i| {
            let totals = Arc::clone(&totals);
            thread::spawn(move || totals.lock().unwrap().push(i * 10))
        })
        .collect();
    for h in hs {
        h.join().unwrap();
    }
    // Recover from poisoning deliberately instead of unwrapping:
    let v = totals.lock().unwrap_or_else(PoisonError::into_inner);
    assert_eq!(v.len(), 4);
}

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::LazyLock; // 1.80
use std::collections::HashMap;

static REQUESTS: AtomicU64 = AtomicU64::new(0);
static LIMITS: LazyLock<HashMap<&'static str, u32>> =
    LazyLock::new(|| HashMap::from([("free", 10), ("pro", 1000)]));

fn handle(plan: &str) -> u32 {
    REQUESTS.fetch_add(1, Ordering::Relaxed); // counter: Relaxed is enough
    LIMITS.get(plan).copied().unwrap_or(0)
}

fn main() {
    assert_eq!(handle("pro"), 1000);
    assert_eq!(REQUESTS.load(Ordering::Relaxed), 1);
}