Advanced Lifetimes

use std::fmt::Debug;

// `T: 'a` is implied by the field `&'a T`; writing it out is optional.
struct Labeled<'a, T: 'a> {
    label: &'static str,
    value: &'a T,
}

fn show<'a, T: Debug + 'a>(item: &Labeled<'a, T>) -> String {
    format!("{}: {:?}", item.label, item.value)
}

fn main() {
    let owned = vec![1, 2, 3];
    let name = String::from("ana");
    let borrowed: &str = &name; // T = &str, which contains a reference

    println!("{}", show(&Labeled { label: "numbers", value: &owned }));
    println!("{}", show(&Labeled { label: "user", value: &borrowed }));
}

use std::fmt::Debug;

fn store_forever<T: Debug + 'static>(value: T) -> Box<dyn Debug> {
    Box::new(value)
}

fn main() {
    let a = store_forever(String::from("owned string")); // String: 'static
    let b = store_forever(vec![1, 2, 3]); // Vec<i32>: 'static
    let c = store_forever("a literal"); // &'static str: 'static
    println!("{a:?} {b:?} {c:?}");

    let temp = String::from("dropped soon");
    drop(temp); // a 'static *type* can still be dropped at any time
    println!("done");
}

use std::thread;

fn main() {
    let config = String::from("port=8080");

    // spawn: the closure must be 'static, so it must own its data.
    let owned = config.clone();
    let h = thread::spawn(move || owned.len());
    println!("spawn saw {} bytes", h.join().unwrap());

    // scope: the closure may borrow, because the scope outlives it.
    let n = thread::scope(|s| s.spawn(|| config.len()).join().unwrap());
    println!("scope saw {n} bytes, and config is still here: {config}");
}

fn first_word<'a>(s: &'a str) -> &'a str {
    s.split_whitespace().next().unwrap_or("")
}

fn pick<'short>(a: &'short str, b: &'short str) -> &'short str {
    if a.len() >= b.len() { a } else { b }
}

fn main() {
    let static_str: &'static str = "hello world";
    let owned = String::from("rustacean");

    // `'static` shrinks to fit the shorter lifetime of `&owned`.
    println!("{}", pick(static_str, &owned));
    println!("{}", first_word(static_str));
}

struct Parser<'input> {
    text: &'input str,
}

impl<'input> Parser<'input> {
    // The result may borrow from `self.text` (lives 'input) or from `fallback` (lives 'f),
    // so both must outlive the returned lifetime 'r.
    fn field_or<'r, 'f>(&self, name: &str, fallback: &'f str) -> &'r str
    where
        'input: 'r,
        'f: 'r,
    {
        self.text
            .split(';')
            .find_map(|kv| kv.strip_prefix(name)?.strip_prefix('='))
            .unwrap_or(fallback)
    }
}

fn main() {
    let p = Parser { text: "host=db.local;port=5432" };
    let default_user = String::from("postgres");
    println!("{}", p.field_or("host", "localhost"));
    println!("{}", p.field_or("user", &default_user));
}

use std::cell::Cell;

fn main() {
    let owned = String::from("short-lived");

    // Covariant: a Vec<&'static str> can be used as a Vec<&'short str>.
    let statics: Vec<&'static str> = vec!["a", "b"];
    let mut mixed: Vec<&str> = statics;
    mixed.push(&owned);
    println!("{mixed:?}");

    // Invariant: a Cell<&'static str> stays exactly that type.
    let cell: Cell<&'static str> = Cell::new("static");
    // cell.set(&owned); // error: `owned` does not live long enough
    println!("{}", cell.get());
}

fn apply_to_all<F>(inputs: &[String], f: F) -> Vec<&str>
where
    F: for<'a> Fn(&'a str) -> &'a str, // same as `F: Fn(&str) -> &str`
{
    inputs.iter().map(|s| f(s)).collect()
}

fn trim_brackets(s: &str) -> &str {
    s.trim_start_matches('[').trim_end_matches(']')
}

fn main() {
    let raw = vec![String::from("[INFO]"), String::from("[WARN]"), String::from("ERROR")];
    println!("{:?}", apply_to_all(&raw, trim_brackets));
    println!("{:?}", apply_to_all(&raw, |s| s.get(..2).unwrap_or(s)));
}

use std::collections::{BTreeSet, HashSet, VecDeque};

fn sum_all<C>(collection: &C) -> u64
where
    for<'a> &'a C: IntoIterator<Item = &'a u64>,
{
    collection.into_iter().sum()
}

fn main() {
    println!("{}", sum_all(&vec![1u64, 2, 3]));
    println!("{}", sum_all(&VecDeque::from([10u64, 20])));
    println!("{}", sum_all(&BTreeSet::from([5u64, 6])));
    println!("{}", sum_all(&HashSet::from([100u64])));
}

fn returns_borrow<F: Fn(&str) -> &str>(f: F) -> F {
    f
}

fn main() {
    let first_line = returns_borrow(|s| s.lines().next().unwrap_or(""));
    let text = String::from("line one\nline two");
    println!("{}", first_line(&text));
}

fn words_longer_than(text: &str, n: usize) -> impl Iterator<Item = &str> {
    text.split_whitespace().filter(move |w| w.len() > n)
}

fn main() {
    let text = String::from("the quick brown fox jumps over the lazy dog");
    let long: Vec<&str> = words_longer_than(&text, 4).collect();
    println!("{long:?}");
}

fn numbered(names: &Vec<String>) -> impl Iterator<Item = usize> + use<> {
    0..names.len()
}

fn main() {
    let mut names = vec![String::from("ana"), String::from("ben")];
    let ids = numbered(&names);
    names.push(String::from("cy"));
    println!("{:?} {names:?}", ids.collect::<Vec<_>>());
}

fn make_filters<'a>(banned: &'a [String], max_len: usize) -> Vec<Box<dyn Fn(&str) -> bool + 'a>> {
    vec![
        Box::new(move |w| !banned.iter().any(|b| b == w)), // borrows `banned`
        Box::new(move |w| w.len() <= max_len),              // owns `max_len`: fits any lifetime
    ]
}

fn main() {
    let banned = vec![String::from("spam"), String::from("scam")];
    let filters = make_filters(&banned, 6);

    let words = ["hello", "spam", "wonderful", "rust"];
    let kept: Vec<&str> = words.into_iter().filter(|w| filters.iter().all(|f| f(w))).collect();
    println!("{kept:?}");
}

trait Extractor<'text> {
    fn extract(&self, text: &'text str) -> Vec<&'text str>;
}

struct Hashtags;
struct Mentions;

impl<'text> Extractor<'text> for Hashtags {
    fn extract(&self, text: &'text str) -> Vec<&'text str> {
        text.split_whitespace().filter(|w| w.starts_with('#')).collect()
    }
}

impl<'text> Extractor<'text> for Mentions {
    fn extract(&self, text: &'text str) -> Vec<&'text str> {
        text.split_whitespace().filter_map(|w| w.strip_prefix('@')).collect()
    }
}

fn run_all<'t>(text: &'t str, extractors: &[&dyn Extractor<'t>]) -> Vec<Vec<&'t str>> {
    extractors.iter().map(|e| e.extract(text)).collect()
}

fn main() {
    let post = String::from("Loving #rust with @ana and @ben #async");
    println!("{:?}", run_all(&post, &[&Hashtags, &Mentions]));
}

trait LendingIterator {
    type Item<'a>
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

struct WindowsMut<'s> {
    data: &'s mut [i32],
    pos: usize,
    size: usize,
}

impl<'s> LendingIterator for WindowsMut<'s> {
    type Item<'a>
        = &'a mut [i32]
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<&'a mut [i32]> {
        let window = self.data.get_mut(self.pos..self.pos + self.size)?;
        self.pos += 1;
        Some(window)
    }
}

fn main() {
    let mut prices = [10, 20, 30, 40];
    let mut windows = WindowsMut { data: &mut prices, pos: 0, size: 2 };

    // Smooth each pair: the second element becomes the average of the pair.
    while let Some(w) = windows.next() {
        w[1] = (w[0] + w[1]) / 2;
    }
    println!("{prices:?}");
}

trait Table {
    type Row<'a>
    where
        Self: 'a;

    fn row<'a>(&'a self, i: usize) -> Option<Self::Row<'a>>;
}

struct Csv {
    text: String,
}

struct Columns {
    names: Vec<String>,
    ages: Vec<u32>,
}

impl Table for Csv {
    type Row<'a> = Vec<&'a str>; // borrowed fields from the text

    fn row<'a>(&'a self, i: usize) -> Option<Vec<&'a str>> {
        Some(self.text.lines().nth(i)?.split(',').collect())
    }
}

impl Table for Columns {
    type Row<'a> = (&'a str, u32); // a borrowed name plus a copied number

    fn row<'a>(&'a self, i: usize) -> Option<(&'a str, u32)> {
        Some((self.names.get(i)?.as_str(), *self.ages.get(i)?))
    }
}

fn main() {
    let csv = Csv { text: String::from("ana,34\nben,40") };
    let cols = Columns { names: vec![String::from("cy")], ages: vec![29] };
    println!("{:?} {:?}", csv.row(1), csv.row(5));
    println!("{:?}", cols.row(0));
}

use std::io::Write;

fn write_header<W: Write>(mut out: W) {
    writeln!(out, "id,name").unwrap();
}

fn main() {
    let mut buf: Vec<u8> = Vec::new();
    let r = &mut buf;

    write_header(&mut *r); // reborrow: `r` is lent out only for this call
    write_header(&mut *r);
    r.extend_from_slice(b"1,ana\n"); // `r` is still ours

    print!("{}", String::from_utf8(buf).unwrap());
}

fn main() {
    let mut ids = vec![10, 20];
    ids.push(ids.len()); // two-phase borrow: len() runs before push activates &mut
    ids.insert(0, ids[1] - 1);

    let mut names = vec![String::from("ana")];
    let copy = names[0].to_uppercase(); // compute first...
    names.push(copy); // ...then mutate: the general-purpose pattern

    println!("{ids:?} {names:?}");
}

use std::marker::PhantomData;

struct Arena {
    names: Vec<String>,
}

// A handle is just an index, but it's tied to the arena's lifetime.
#[derive(Clone, Copy, Debug)]
struct Handle<'arena> {
    index: usize,
    _borrows: PhantomData<&'arena Arena>,
}

impl Arena {
    fn find(&self, name: &str) -> Option<Handle<'_>> {
        let index = self.names.iter().position(|n| n == name)?;
        Some(Handle { index, _borrows: PhantomData })
    }

    fn get(&self, h: Handle<'_>) -> &str {
        &self.names[h.index]
    }
}

fn main() {
    let arena = Arena { names: vec![String::from("ana"), String::from("ben")] };
    let h = arena.find("ben").unwrap();
    println!("{:?} -> {}", h, arena.get(h));
    println!("size of a handle: {} bytes", std::mem::size_of::<Handle>());
    // drop(arena); println!("{h:?}"); // error: `arena` is borrowed by `h`
}

use std::any::Any;

fn describe(value: &dyn Any) -> String {
    if let Some(n) = value.downcast_ref::<i32>() {
        format!("an i32: {n}")
    } else if let Some(s) = value.downcast_ref::<String>() {
        format!("a String of length {}", s.len())
    } else if let Some(s) = value.downcast_ref::<&'static str>() {
        format!("a static str: {s}")
    } else {
        String::from("something else")
    }
}

fn main() {
    println!("{}", describe(&42));
    println!("{}", describe(&String::from("hello")));
    println!("{}", describe(&"literal"));
    println!("{}", describe(&vec![1.5]));
}

#[derive(Debug, PartialEq)]
enum Token<'src> {
    Ident(&'src str),
    Number(&'src str),
    Symbol(char),
}

trait Tokenizer {
    fn tokens<'src>(&self, src: &'src str) -> Vec<Token<'src>>;
}

struct Simple;

impl Tokenizer for Simple {
    fn tokens<'src>(&self, src: &'src str) -> Vec<Token<'src>> {
        let mut out = Vec::new();
        let mut rest = src;
        while let Some(c) = rest.chars().next() {
            if c.is_whitespace() {
                rest = &rest[c.len_utf8()..];
            } else if c.is_alphanumeric() {
                let end = rest.find(|ch: char| !ch.is_alphanumeric()).unwrap_or(rest.len());
                let (word, tail) = rest.split_at(end);
                out.push(if word.chars().all(|ch| ch.is_ascii_digit()) { Token::Number(word) } else { Token::Ident(word) });
                rest = tail;
            } else {
                out.push(Token::Symbol(c));
                rest = &rest[c.len_utf8()..];
            }
        }
        out
    }
}

fn identifiers<'src>(t: &dyn Tokenizer, src: &'src str) -> Vec<&'src str> {
    t.tokens(src).into_iter().filter_map(|tok| if let Token::Ident(s) = tok { Some(s) } else { None }).collect()
}

fn main() {
    let source = String::from("total = price * 3 + tax");
    println!("{:?}", Simple.tokens(&source));
    println!("{:?}", identifiers(&Simple, &source));
}

use std::cell::{Cell, RefCell};

#[derive(Debug)]
enum Event<'e> {
    Click { x: i32, y: i32 },
    Key(&'e str),
}

struct Bus<'a> {
    listeners: Vec<Box<dyn Fn(&Event) + 'a>>,
}

impl<'a> Bus<'a> {
    fn on(&mut self, f: impl Fn(&Event) + 'a) {
        self.listeners.push(Box::new(f));
    }

    fn emit(&self, e: &Event) {
        for l in &self.listeners {
            l(e);
        }
    }
}

fn main() {
    let clicks = Cell::new(0);
    let typed = RefCell::new(String::new());

    {
        let mut bus = Bus { listeners: Vec::new() };
        bus.on(|e| {
            if let Event::Click { .. } = e {
                clicks.set(clicks.get() + 1);
            }
        });
        bus.on(|e| {
            if let Event::Key(k) = e {
                typed.borrow_mut().push_str(k);
            }
        });

        let key_text = String::from("hi");
        bus.emit(&Event::Click { x: 1, y: 2 });
        bus.emit(&Event::Key(&key_text));
        bus.emit(&Event::Click { x: 3, y: 4 });
    } // the bus and its borrowing listeners end here

    println!("clicks: {}, typed: {:?}", clicks.get(), typed.into_inner());
}

use std::collections::HashMap;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct Symbol(u32);

#[derive(Default)]
struct Interner {
    lookup: HashMap<String, Symbol>,
    strings: Vec<String>,
}

impl Interner {
    fn intern(&mut self, s: &str) -> Symbol {
        if let Some(&sym) = self.lookup.get(s) {
            return sym;
        }
        let sym = Symbol(self.strings.len() as u32);
        self.strings.push(s.to_string());
        self.lookup.insert(s.to_string(), sym);
        sym
    }

    fn resolve(&self, sym: Symbol) -> &str {
        &self.strings[sym.0 as usize]
    }
}

fn main() {
    let mut interner = Interner::default();
    let log = "GET /home GET /cart POST /cart GET /home";

    let symbols: Vec<Symbol> = log.split_whitespace().map(|w| interner.intern(w)).collect();
    println!("{} words, {} distinct strings stored", symbols.len(), interner.strings.len());

    let cart = interner.intern("/cart");
    let cart_hits = symbols.iter().filter(|&&s| s == cart).count(); // comparing u32s, not strings
    println!("{} appears {cart_hits} times", interner.resolve(cart));
}