Advanced Lifetimes

struct Context<'cfg> { prefix: &'cfg str }

// The returned &str lives as long as the config ('cfg), not as long as the short borrow of the context ('c).
fn prefix<'c, 'cfg: 'c>(ctx: &'c Context<'cfg>) -> &'cfg str {
    ctx.prefix
}

fn store<'a, T: 'a>(slot: &mut Vec<Box<dyn std::fmt::Debug + 'a>>, v: T)
where
    T: std::fmt::Debug,
{
    slot.push(Box::new(v)); // without T: 'a -> E0310 "the parameter type `T` may not live long enough"
}

fn push_local<'a>(v: &mut Vec<&'a str>, s: &'a str) {
    v.push(s);
}

fn demo() {
    let mut names: Vec<&'static str> = vec!["a"];
    let owned = String::from("b");
    // push_local(&mut names, &owned); // error: `owned` does not live long enough
    //                                 // (&mut is invariant: 'a is forced to 'static)
    let mut names2: Vec<&str> = names.clone(); // a Vec with a shorter element lifetime
    push_local(&mut names2, &owned);
    names.push("c");
}

use std::marker::PhantomData;

/// A cursor into a buffer it does not store, tied to the buffer's lifetime.
struct Cursor<'buf> {
    ptr: *const u8,
    len: usize,
    _buf: PhantomData<&'buf [u8]>,
}

impl<'buf> Cursor<'buf> {
    fn new(buf: &'buf [u8]) -> Self {
        Cursor { ptr: buf.as_ptr(), len: buf.len(), _buf: PhantomData }
    }
    fn len(&self) -> usize { self.len }
}

/// A typed id that borrows nothing.
struct Id<T> { raw: u32, _t: PhantomData<fn() -> T> }

// These two bounds are identical:
fn apply<F: Fn(&str) -> &str>(f: F, s: &str) -> String { f(s).to_string() }
fn apply_explicit<F>(f: F, s: &str) -> String
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    f(s).to_string()
}

fn sum_all<T>(c: &T) -> u32
where
    for<'a> &'a T: IntoIterator<Item = &'a u32>,
{
    c.into_iter().sum()
}

fn main() {
    let v = vec![1, 2, 3];
    assert_eq!(sum_all(&v), 6);
}

struct Lines<'a> { rest: &'a str }

impl<'a> Iterator for Lines<'a> {
    type Item = &'a str;                 // items outlive each call to next()

    fn next(&mut self) -> Option<&'a str> {
        if self.rest.is_empty() {
            return None;
        }
        let (line, rest) = self.rest.split_once('\n').unwrap_or((self.rest, ""));
        self.rest = rest;
        Some(line)
    }
}

fn lines(s: &str) -> Lines<'_> { Lines { rest: s } }

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

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

struct WindowsMut<'t, T> { data: &'t mut [T], start: usize, size: usize }

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

    fn next<'a>(&'a mut self) -> Option<&'a mut [T]> {
        let end = self.start + self.size;
        if end > self.data.len() {
            return None;
        }
        let w = &mut self.data[self.start..end];
        self.start += 1;
        Some(w)
    }
}

fn main() {
    let mut v = [1, 2, 3, 4];
    let mut it = WindowsMut { data: &mut v, start: 0, size: 2 };
    while let Some(w) = it.next() {
        w[0] += w[1];                    // each window is dropped before the next call
    }
    assert_eq!(v, [3, 5, 7, 4]);
}

// Returning a closure that borrows an argument: tie the closure to the borrow.
fn contains_any<'a>(needles: &'a [&str]) -> impl Fn(&str) -> bool + 'a {
    move |hay| needles.iter().any(|n| hay.contains(n))
}

// Returning a reference from a closure parameter needs an explicit signature or a helper:
fn first_word(s: &str) -> &str { s.split(' ').next().unwrap_or("") }

fn main() {
    let f = contains_any(&["err", "warn"]);
    assert!(f("warn: disk"));
    let words: Vec<&str> = ["a b", "c d"].iter().map(|s| first_word(s)).collect();
    assert_eq!(words, ["a", "c"]);
}