fn main() {
    let r;                  // declare r — no value yet

    {
        let x = 5;
        r = &x;             // r borrows x
    }                       // x is dropped here — r now dangles

    println!("{}", r);      // ERROR: x does not live long enough
}

// BAD — r outlives x

fn main() {
    let r;                      // ------+-- r's lifetime begins
    {                           //       |
        let x = 5;              // -+    |   x's lifetime begins
        r = &x;                 //  |    |
    }                           // -+    |   x dropped — r still alive!
    println!("{}", r);          // ------+   COMPILER ERROR
}

// GOOD — r lives within x

fn main() {
    let x = 5;                  // ------+-- x's lifetime begins
    let r = &x;                 //    ---+-- r's lifetime begins (nested inside x)
    println!("{}", r);          //       |   used here — x still alive: OK
}                               // ------+-- both dropped

&str          // a reference — no lifetime annotation
&'a str       // a reference with explicit lifetime 'a
&'a mut str   // a mutable reference with explicit lifetime 'a

// This does NOT compile — the compiler cannot determine the return lifetime
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

// Correct version — annotated with 'a
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");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("longest: {}", result); // OK — result used inside s2's scope
    }
    // println!("{}", result); // would ERROR — s2 dropped, result could dangle
}

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

struct Important<'a> {
    part: &'a str,
}

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

    let excerpt = Important { part: first_sentence };
    println!("Important part: {}", excerpt.part);
}   // novel and excerpt are both dropped here — safe

struct Important<'a> {
    part: &'a str,
}

impl<'a> Important<'a> {
    // Method that returns a reference — lifetime elision applies (see next page)
    fn announce(&self, announcement: &str) -> &str {
        println!("Attention: {}!", announcement);
        self.part
    }
}

fn main() {
    let text = String::from("some important text");
    let imp = Important { part: &text };
    let part = imp.announce("listen up");
    println!("The important part: {}", part);
}

// String literals have type &'static str
let s: &'static str = "I live forever";

// Functions can require 'static when storing references long-term
fn needs_static(s: &'static str) {
    println!("{}", s);
}

fn main() {
    needs_static("hello");          // OK — string literal is 'static

    let owned = String::from("world");
    // needs_static(&owned);        // ERROR — &owned is not 'static
}

// The return value's lifetime is tied to x, not y
fn mixed<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    println!("y is: {}", y);
    x
}

fn main() {
    let s1 = String::from("hello");
    let result;
    {
        let s2 = String::from("world");
        result = mixed(s1.as_str(), s2.as_str());
        // s2 can be dropped because result's lifetime only depends on s1
    }
    println!("result: {}", result); // OK — s1 still alive
}

use std::fmt::Display;

// T must implement Display and live at least as long as 'a
fn print_ref<'a, T>(val: &'a T)
where
    T: Display + 'a,
{
    println!("{}", val);
}

struct Wrapper<'a, T: 'a> {
    value: &'a T,
}

fn main() {
    let number = 42;
    print_ref(&number);

    let w = Wrapper { value: &number };
    println!("wrapped: {}", w.value);
}

use std::fmt::Display;

fn longest_with_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    announcement: T,
) -> &'a str
where
    T: Display,
{
    println!("Announcement: {}", announcement);
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");
    let s2 = String::from("xyz");
    let result = longest_with_announcement(
        s1.as_str(),
        s2.as_str(),
        "Today's winner is...",
    );
    println!("Longest: {}", result);
}

Borrow checker flow for longest<'a>(x: &'a str, y: &'a str) -> &'a str

  Call site:      longest(s1.as_str(), s2.as_str())
                        |                  |
  Lifetimes:      'a = lifetime of s1    'a = lifetime of s2
                  -> 'a is the SHORTER of the two
                  -> return value must be used within that shorter region

  Checker verifies: is the return value used only while both s1 and s2 are alive?
  If yes: compile. If no: error.