Lifetimes

fn dangle() -> &String {
    let s = String::from("hello"); // s created here, owned by dangle()
    &s // ❌ ERROR: we return a reference to s...
} // ...but s is dropped HERE, at the end of the function!
  // The reference we tried to return would point to freed memory.
  // error[E0106]: missing lifetime specifier
  // help: this function's return type contains a borrowed value
  //       with no value for it to be borrowed from

fn main() {
    // let s = dangle(); // would be a dangling reference if this compiled
}

fn no_dangle() -> String {       // return type is OWNED String, not &String
    let s = String::from("hello");
    s // ✅ ownership MOVES out to the caller — s is not dropped
}

fn main() {
    let result = no_dangle();
    println!("{}", result); // ✅ "hello" — result owns the data now
}

// 'a says: the returned reference will live AT MOST as long as
// the SHORTER of x's and y's lifetimes.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let s1 = String::from("long string is long");
    let s2 = String::from("short");

    let result = longest(s1.as_str(), s2.as_str());
    println!("Longest string is: {}", result); // "long string is long"
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string is long");
    let result;
    {
        let s2 = String::from("short"); // s2 lives only in this inner scope
        result = longest(s1.as_str(), s2.as_str());
    } // s2 dropped here
    // 'a was forced to shrink to s2's lifetime (the shorter one)
    // so `result` is only valid INSIDE the block above.
    println!("Longest string is: {}", result);
    // ❌ ERROR: `s2` does not live long enough
    // `result` may still borrow from `s2`, but `s2` is already dropped
}

// ExcerptHolder borrows a &str — it does NOT own the string data.
// 'a ties the struct's lifetime to the lifetime of that borrowed &str.
struct ExcerptHolder<'a> {
    part: &'a str,
}

impl<'a> ExcerptHolder<'a> {
    // Rule 3 (elision): &self's lifetime is assigned to the output
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("no '.' found");

    let excerpt = ExcerptHolder { part: first_sentence };
    // `excerpt` cannot outlive `novel` — enforced at compile time

    println!("{}", excerpt.part); // "Call me Ishmael"
    let _ = excerpt.announce_and_return_part("New excerpt!");
}

fn main() {
    // String literals are &'static str — baked into the binary's read-only data segment
    let s: &'static str = "I live for the whole program";
    println!("{}", s);

    // A function that returns a 'static reference
    fn get_app_name() -> &'static str {
        "rust-job-prep" // literal — always valid, no owner to drop
    }
    println!("{}", get_app_name());
}

// ⚠️  COMMON MISTAKE: 'static does NOT mean "leak memory" or "live forever
// no matter what". It means "CAN live that long if needed" — for owned data
// like Box, you'd need Box::leak() to actually get a 'static reference,
// which intentionally leaks memory. Don't reach for 'static to "fix" a
// lifetime error — it usually means restructuring ownership instead.

// 'a and 'b are INDEPENDENT — x and y can have totally different lifetimes.
// The output only depends on 'a (x's lifetime), so 'b has no constraint
// on the bound 'a: 'b means "'a must outlive 'b" — used when needed.
fn first_word_with_logger<'a, 'b>(text: &'a str, logger_tag: &'b str) -> &'a str {
    println!("[{}] processing text...", logger_tag); // 'b only used here

    match text.find(' ') {
        Some(idx) => &text[..idx],
        None => text,
    }
}

fn main() {
    let sentence = String::from("lifetimes are not that scary");
    let word;
    {
        let tag = String::from("PARSER"); // short-lived 'b
        word = first_word_with_logger(&sentence, &tag);
    } // tag dropped here — but `word` is fine, it only borrows from `sentence` ('a)

    println!("first word: {}", word); // ✅ "lifetimes" — still valid!
}

use std::borrow::Cow;

// Returns a borrowed slice if no change is needed, or an owned String
// only when mutation is actually required — avoids unnecessary allocation.
fn normalize<'a>(input: &'a str) -> Cow<'a, str> {
    if input.contains(' ') {
        Cow::Owned(input.replace(' ', "_")) // allocates a new String
    } else {
        Cow::Borrowed(input) // zero allocation — just a reference
    }
}

fn main() {
    let a = normalize("already_clean");  // Cow::Borrowed — no allocation
    let b = normalize("needs spaces");  // Cow::Owned — one allocation

    println!("{} | {}", a, b); // "already_clean | needs_spaces"

    // HRTB example: a closure that must accept &T for ANY lifetime 'a
    // — common in iterator/visitor-style APIs
    fn apply_to_all(items: &[String], f: F)
    where
        F: for<'a> Fn(&'a String) -> usize,
    {
        for item in items {
            println!("len = {}", f(item));
        }
    }
    apply_to_all(&[String::from("a"), String::from("bb")], |s| s.len());
}