Lifetimes ('a)

// Lifetime annotation in a function signature
fn function_name<'a>(x: &'a str, y: &'a str) -> &'a str { ... }

// Lifetime in a struct field
struct StructName<'a> {
    field: &'a str,
}

// Static lifetime (valid for the entire program)
let s: &'static str = "hello";

// Returns the longer of two string slices.
// The return value has the same lifetime as the arguments.
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

// A struct that holds a reference with a lifetime
struct Important<'a> {
    content: &'a str,
}

impl<'a> Important<'a> {
    fn display(&self) {
        println!("{}", self.content);
    }
}

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); // result can only be used while s2 is valid.
    }

    // Static lifetime
    let s: &'static str = "Valid until the program ends";
    println!("{}", s);

    let novel = String::from("The story begins. In the next chapter...");
    let first_sentence;
    {
        let i = Important {
            content: novel.split('.').next().unwrap(),
        };
        i.display();
        first_sentence = i.content;
    }
    println!("{}", first_sentence);
}

Lifetime annotations do not change how long a reference is valid — they simply tell the compiler about the relationship between the lifetimes of multiple references. In many cases, the compiler can infer lifetimes automatically through "lifetime elision rules," so explicit annotations are not always required.

A lifetime mismatch causes a compile error. When a function returns a reference, the lifetime of the return value must be tied to the lifetime of one of its parameters.

For the basics of references, see Borrowing / References (&).