Rust: Rust Lifetimes: Annotating the Validity of References

The tracker locks onto the mouse A → Mouse A ran into the cave → The tracker is still pointing toward the entrance.

// Life Cycle Annotation 'a: Tell the compiler "the validity period of the return value does not exceed that of parameter x's validity period"
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let string1 = String::from("Long Strings");
    let result;

    {
        let string2 = String::from("short");
        result = longest(&string1, &string2);  // ✅ string2 and string1 are both still alive
        println!("The longer one is: {}", result);
    }  // string2 Destroyed here

    // println!("{}", result);  // ❌ If you print here, result references string2 which is destroyed
}  // string1 Destroyed here

fn main() {
    let x: i32 = 10;           // x Its life cycle begins here
    let r: &i32 = &x;          // r Its life cycle begins here
    println!("r: {}", r);       // Usage r
}                               // r whose lifecycle ends first, then x ends

// 'a is the name of the lifecycle parameter (using 'a, 'b, 'c)
// Pronunciation: Regarding the lifecycle 'a, both x and y need to be alive for at least 'a

fn function<'a>(x: &'a str, y: &'a str) -> &'a str {
    // The lifecycle of return values = the shorter of x and y
}

// No annotation required: there is only one input reference
fn first_word(s: &str) -> &str { &s[..] }

// Needs annotation: two input references
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

The longer one is: <result>
<result>

// ============================================
// What happens if there are no lifecycle annotations?
// ============================================

// This function has two input references, the return value could be any one of these
// ❌ If not annotated, a compilation error will occur: expected lifetime parameter
// fn longest_wrong(x: &str, y: &str) -> &str {
//     if x.len() > y.len() { x } else { y }
// }

// ✅ Correct Version: Lifecycle Annotation
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("hello");
    let result;

    {
        let s2 = String::from("hi");
        result = longest(&s1, &s2);  // result lifecycle = s2 lifecycle (the shorter one)
        println!("The longer one is: {}", result);
    }  // s2 destroyed, result invalid

    // println!("{}", result);  // ❌ The compiler will prevent: result's lifecycle has ended
}

result: <result>
Remains valid even after leaving the inner layer: <result>

result: <result>
Remains valid even after leaving the inner layer: <result>

// ============================================
// The two parameters have different lifecycles.
// ============================================

// Two Lifecycles: 'a corresponds to x, 'b corresponds to y
// The return value depends only on x, so use 'a
fn choose_first<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    x  // Return only x, so the lifecycle only needs 'a
}

fn main() {
    let x = String::from("Live to be a hundred years old");
    let result;
    {
        let y = String::from("Short-lived ghost");
        result = choose_first(&x, &y);  // ✅ result Depends solely on x
        println!("result: {}", result);
    }  // y destroyed, but result does not depend on y, so no problem

    println!("Remains valid even after leaving the inner layer: {}", result);  // ✅ x Still Alive
}

result: Live to be a hundred years old
Remains valid even after leaving the inner layer: Live to be a hundred years old

Announcement: <announcement>

Announcement: <announcement>
Excerpt: <excerpt.content>
Length: <excerpt.length()>
Announcement of Results: <excerpt.announce("Welcome to this article")>

// ============================================
// Storing references in a structure -- the lifecycle must be specified.
// ============================================

struct Excerpt<'a> {
    content: &'a str,  // Structures Borrow External Strings
}

impl<'a> Excerpt<'a> {
    fn length(&self) -> usize {
        self.content.len()
    }

    fn announce(&self, announcement: &str) -> &str {
        println!("Announcement: {}", announcement);
        self.content  // Returning a Reference to the Interior of a Structure
    }
}

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

    let excerpt = Excerpt {
        content: &first_sentence,
    };

    println!("Excerpt: {}", excerpt.content);
    println!("Length: {}", excerpt.length());
    println!("Announcement of Results: {}", excerpt.announce("Welcome to this article"));
}  // excerpt must be destroyed before novel (content depends on novel)

Excerpt: Call me Ishmael
Length: 15
Announcement of Results: Call me Ishmael

I exist throughout the entire lifecycle of a program
<std::ptr::from_ref(val)>

// ============================================
// 'static: the reference remains valid throughout the program's execution.
// ============================================

fn main() {
    // A string literal is 'static
    let s: &'static str = "I exist throughout the entire lifecycle of a program";
    println!("{}", s);

    // 'static Constraints: T must not contain any non-static references
    fn print_static<T: 'static>(val: &T) {
        println!("{:?}", std::ptr::from_ref(val));
    }

    let num: i32 = 42;
    print_static(&num);  // ✅ i32 excludes references, complies with 'static

    // let msg = String::from("temp");
    // let r = &msg;
    // print_static(&r);  // ❌ r references non-'static msg
}

I exist throughout the entire lifecycle of a program
0x...(Memory Address)

=== Text Analysis ===

=== Text Analysis ===
<analyzer.summary()>

First 3 words: <top3>
Includes 'Rust' the word: <rust_mentions>

// ============================================
// Life Cycle in Practice: Zero-Copy Text Analysis
// ============================================

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

impl<'a> TextAnalyzer<'a> {
    fn new(text: &'a str) -> Self {
        TextAnalyzer { text }
    }

    fn word_count(&self) -> usize {
        self.text.split_whitespace().count()
    }

    fn longest_word(&self) -> &'a str {
        self.text
            .split_whitespace()
            .max_by_key(|w| w.len())
            .unwrap_or("")
    }

    fn first_n_words(&self, n: usize) -> Vec<&'a str> {
        self.text.split_whitespace().take(n).collect()
    }

    fn line_count(&self) -> usize {
        self.text.lines().count()
    }

    fn char_count(&self) -> usize {
        self.text.chars().count()
    }

    fn summary(&self) -> String {
        format!(
            "Character: {}, Words: {}, Number of lines: {}, Longest Word: '{}'",
            self.char_count(),
            self.word_count(),
            self.line_count(),
            self.longest_word()
        )
    }
}

fn highlight_word<'a>(text: &'a str, word: &str) -> Vec<&'a str> {
    text.split_whitespace()
        .filter(|w| w.contains(word))
        .collect()
}

fn main() {
    let article = "Rust is a systems programming language \
that runs blazingly fast and prevents segfaults. \
Rust guarantees memory safety and thread safety.";

    let analyzer = TextAnalyzer::new(article);
    println!("=== Text Analysis ===");
    println!("{}", analyzer.summary());

    let top3 = analyzer.first_n_words(3);
    println!("\nFirst 3 words: {:?}", top3);

    let rust_mentions = highlight_word(article, "Rust");
    println!("Includes 'Rust' the word: {:?}", rust_mentions);

    let paragraph = "First line.\nSecond line.\nThird line.";
    let p_analyzer = TextAnalyzer::new(paragraph);
    println!("\nParagraph Analysis: {}", p_analyzer.summary());
}

=== Text Analysis ===
Character: 124, Words: 18, Number of lines: 1, Longest Word: 'blazingly'

First 3 words: ["Rust", "is", "a"]
Includes 'Rust' the word: ["Rust", "Rust"]

Paragraph Analysis: Character: 39, Words: 6, Number of lines: 3, Longest Word: 'Second'