Collections

fn main() {
    let mut titles: Vec<String> = Vec::new();            // no allocation yet
    titles.push("Dune".to_string());
    titles.push("Emma".to_string());
    let mut shelf = vec!["Kindred", "Beloved"];          // vec! macro
    shelf.push("Ulysses");
    let mut zeros = vec![0u8; 16];                       // 16 zeros
    zeros.truncate(8);

    println!("{} {} {}", titles.len(), shelf[1], zeros.len());
    if let Some(last) = titles.pop() {                   // remove from the end
        println!("popped {last}");
    }
    titles.insert(0, "Middlemarch".into());              // O(n): shifts elements
    titles.extend(shelf.iter().map(|s| s.to_string()));
    let removed = titles.remove(1);                      // O(n)
    println!("{titles:?} (removed {removed})");
}

use std::collections::VecDeque;

fn main() {
    let mut holds: VecDeque<&str> = VecDeque::new();   // reservation queue for one book
    holds.push_back("alice");
    holds.push_back("bob");
    holds.push_front("vip");                            // jumps the queue
    while let Some(member) = holds.pop_front() {
        println!("notify {member}");
    }

    let mut window: VecDeque<u32> = VecDeque::with_capacity(3); // last three ratings
    for r in [5, 4, 2, 3, 5] {
        if window.len() == 3 {
            window.pop_front();
        }
        window.push_back(r);
    }
    println!("{window:?}"); // [2, 3, 5]
}

use std::collections::{HashMap, HashSet};

fn main() {
    let mut copies: HashMap<String, u32> = HashMap::new();
    copies.insert("Dune".to_string(), 2);
    copies.insert("Emma".to_string(), 1);
    let old = copies.insert("Dune".to_string(), 3);       // replaces and returns the old value
    println!("{old:?} {:?} {}", copies.get("Dune"), copies.contains_key("Ulysses"));

    if let Some(n) = copies.get_mut("Emma") {
        *n += 1;
    }
    let removed = copies.remove("Emma");
    println!("{removed:?} {}", copies.len());

    let from_pairs: HashMap<&str, u16> = [("Dune", 1965), ("Emma", 1815)].into_iter().collect();
    let literal = HashMap::from([("Kindred", 1979)]);
    println!("{from_pairs:?} {literal:?}");

    let tags: HashSet<&str> = ["sci-fi", "classic", "sci-fi"].into_iter().collect();
    let wanted: HashSet<&str> = ["classic", "romance"].into_iter().collect();
    println!("{} {:?}", tags.len(), tags.intersection(&wanted).collect::<Vec<_>>()); // 2 ["classic"]
}

use std::collections::{BTreeMap, BTreeSet};

fn main() {
    let mut by_year: BTreeMap<u16, &str> = BTreeMap::new();
    for (y, t) in [(1965, "Dune"), (1815, "Emma"), (1987, "Beloved"), (1922, "Ulysses"), (1979, "Kindred")] {
        by_year.insert(y, t);
    }
    for (year, title) in &by_year {
        print!("{year}:{title} ");                       // iterates in key order
    }
    println!();
    let twentieth: Vec<_> = by_year.range(1900..2000).map(|(_, t)| *t).collect();
    println!("{twentieth:?}");                           // ["Ulysses", "Dune", "Kindred", "Beloved"]
    println!("{:?} {:?}", by_year.first_key_value(), by_year.last_key_value());

    let isbn_prefixes: BTreeSet<&str> = ["979", "978", "978"].into_iter().collect();
    println!("{isbn_prefixes:?}");                       // {"978", "979"}
}

use std::cmp::Reverse;
use std::collections::BinaryHeap;

fn main() {
    // (due day, member): the soonest due date should come out first.
    let mut reminders = BinaryHeap::new();
    reminders.push(Reverse((14, "alice")));
    reminders.push(Reverse((3, "bob")));
    reminders.push(Reverse((7, "carol")));
    while let Some(Reverse((day, member))) = reminders.pop() {
        println!("day {day}: remind {member}");     // 3 bob, 7 carol, 14 alice
    }
}