Lifetime Elision and Lifetime Errors

fn compare(a: &str, b: &str) -> bool { a == b }
// is
fn compare_explicit<'x, 'y>(a: &'x str, b: &'y str) -> bool { a == b }

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

fn label(prefix: &'static str, n: u32) -> &str {
    let _ = n;
    prefix // output gets 'static: the only input lifetime
}

use std::collections::HashMap;

struct Cache {
    map: HashMap<String, String>,
}

impl Cache {
    // Output borrows self, not key.
    fn get(&self, key: &str) -> Option<&String> {
        self.map.get(key)
    }

    // Output borrows the argument, not self: rule 3 would be wrong, so name it.
    fn or_default<'a>(&self, key: &str, fallback: &'a String) -> &'a String {
        let _ = key;
        fallback
    }
}

error: lifetime may not live long enough
  |     fn pick(&self, other: &str) -> &str {
  |             -             - let's call the lifetime of this reference `'1`
  |             |
  |             let's call the lifetime of this reference `'2`
  |         other
  |         ^^^^^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`

#![warn(rust_2018_idioms)]

error[E0106]: missing lifetime specifier
 --> src/lib.rs:1:33
  |
1 | fn longer(a: &str, b: &str) -> &str {
  |              ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter

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

fn greeting(name: &str) -> String {
    format!("hello {name}")
}

fn level_name(level: u8) -> &'static str {
    match level {
        0 => "error",
        1 => "warn",
        _ => "info",
    }
}

struct Token<'a> {
    text: &'a str,
}

struct OwnedToken {
    text: String,
}

// error[E0621]: explicit lifetime required in the type of `fallback`
// fn get_or<'a>(map: &'a std::collections::HashMap<String, String>, k: &str, fallback: &str) -> &'a str {
//     map.get(k).map(String::as_str).unwrap_or(fallback)
// }

fn get_or<'a>(map: &'a std::collections::HashMap<String, String>, k: &str, fallback: &'a str) -> &'a str {
    map.get(k).map(String::as_str).unwrap_or(fallback)
}

struct Holder<'a> {
    items: Vec<&'a str>,
}

impl<'a> Holder<'a> {
    // error: lifetime may not live long enough
    // fn add(&mut self, s: &str) { self.items.push(s); }
    //   argument `s` has lifetime '1, but items need 'a

    fn add(&mut self, s: &'a str) {
        self.items.push(s);
    }
}

// fn names() -> Vec<&'static str> { let s = String::from("a,b"); s.split(',').collect() }  // E0515
fn names(csv: &str) -> Vec<&str> {
    csv.split(',').collect() // borrows the caller's string instead
}

fn names_owned() -> Vec<String> {
    let s = String::from("a,b");
    s.split(',').map(str::to_owned).collect()
}

fn main() {
    let words: Vec<&str>;
    {
        let text = String::from("a b c");
        // words = text.split(' ').collect(); // E0597: `text` dropped here while still borrowed
        let _ = &text;
    }
    let text = String::from("a b c"); // move the owner to the outer scope
    words = text.split(' ').collect();
    println!("{words:?}");

    // E0716: let s: &str = String::from("tmp").as_str(); then use s
    let owned = String::from("tmp"); // bind the temporary
    let s: &str = owned.as_str();
    println!("{s}");
}

error[E0310]: the parameter type `T` may not live long enough
  |
  |     Box::new(value)
  |     ^^^^^^^^^^^^^^^ the parameter type `T` must be valid for the static lifetime...
  |                     ...so that the type `T` will meet its required lifetime bounds
help: consider adding an explicit lifetime bound
  |
  | fn boxed<T: Debug + 'static>(value: T) -> Box<dyn Debug> {

use std::fmt::Debug;

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

// or keep borrowed T allowed by tying the object lifetime:
fn boxed_any<'a, T: Debug + 'a>(value: T) -> Box<dyn Debug + 'a> {
    Box::new(value)
}

use std::thread;

// fn spawn_print(s: &str) { thread::spawn(move || println!("{s}")); }
// error[E0521]: borrowed data escapes outside of function: `s` escapes the function body here

fn spawn_print(s: &str) -> thread::JoinHandle<()> {
    let owned = s.to_owned();
    thread::spawn(move || println!("{owned}"))
}

fn scoped_print(s: &str) {
    thread::scope(|scope| {
        scope.spawn(|| println!("{s}")); // scoped threads may borrow (1.63+)
    });
}

struct Lexer<'a> {
    src: &'a str,
    pos: usize,
}

impl<'a> Lexer<'a> {
    // BAD: fn next(&'a mut self) -> Option<&'a str>
    // let mut lx = Lexer { src, pos: 0 }; lx.next(); lx.next();
    // error[E0499]: cannot borrow `lx` as mutable more than once at a time
    fn next(&mut self) -> Option<&'a str> {
        let rest = self.src.get(self.pos..)?;
        let end = rest.find(' ').map_or(rest.len(), |i| i + 1);
        self.pos += end;
        if end == 0 { None } else { Some(rest[..end].trim_end()) }
    }
}

use std::marker::PhantomData;

// struct Slice<'a, T> { ptr: *const T, len: usize }   // error[E0392]: lifetime parameter `'a` is never used
struct Slice<'a, T> {
    ptr: *const T,
    len: usize,
    _borrow: PhantomData<&'a [T]>, // "behaves as if it holds &'a [T]": covariant, ties drop check
}

// fn chars_of(s: &str) -> impl Iterator<Item = char> { s.chars() }
// edition 2021: error[E0700]: hidden type for `impl Iterator<Item = char>` captures lifetime
// that does not appear in bounds
fn chars_of(s: &str) -> impl Iterator<Item = char> + '_ {
    s.chars()
}

// fn f(x: &'a str) {}            // E0261: declare it: fn f<'a>(x: &'a str)
// fn g<'static>(x: &'static str) // E0262: 'static cannot be declared
fn f<'a>(x: &'a str) -> &'a str { x }

struct Name<'a>(&'a str);

trait Greet {
    fn greet(&self) -> String;
}

// impl Greet for Name { .. }   // error[E0726]: implicit elided lifetime not allowed here
impl Greet for Name<'_> {
    fn greet(&self) -> String {
        format!("hi {}", self.0)
    }
}

1. Does it return a reference (or a type with a lifetime: Cow, Iter, impl Trait capturing, Token<'_>)?
   no  -> elide everything; name lifetimes only for bounds you need (T: 'a, 'a: 'b)
2. Is there &self / &mut self, and does the result borrow from self?
   yes -> elide (rule 3)
   result borrows from an argument instead -> name 'a on that argument and the output
3. Exactly one input lifetime?             -> elide (rule 2)
4. Several input lifetimes:
   result from exactly one input           -> 'a on that input + output only
   result from any of them                 -> 'a on all of them
5. No input lifetime                       -> return owned data, or &'static for literals/globals
6. Storing an argument into self?          -> the argument needs the struct's lifetime: s: &'a str
7. Run the scripts (`/tmp/missing_lifetime file.rs`, `/tmp/elision_check file.rs`) and cargo check