Lifetime annotations in Rust - Mini Project: Build & Apply

Understanding Lifetime Annotations in Rust

📖 Scenario: Imagine you are building a simple Rust program that manages references to text data. You want to ensure your program handles references safely without dangling pointers or invalid data access.

🎯 Goal: Learn how to use lifetime annotations in Rust to tell the compiler how long references should be valid. You will create a function that returns the longest string slice from two inputs, using lifetime annotations to keep the references safe.

📋 What You'll Learn

Create two string slices as input references with explicit lifetime annotations

Write a function called longest that takes two string slices with lifetime annotations and returns the longest slice

Use lifetime annotations correctly to avoid compiler errors

Print the result of calling longest with two string slices

💡 Why This Matters

🌍 Real World

Lifetime annotations are essential in Rust programs that handle references to ensure memory safety without garbage collection. They help prevent bugs like dangling pointers.

💼 Career

Understanding lifetimes is crucial for Rust developers working on systems programming, embedded software, or any application where safe and efficient memory management is required.

1

Create two string slices with explicit lifetime annotations

Create two string slices called string1 and string2 with the values "hello" and "world" respectively. Use explicit lifetime annotations &'a str in their types.

Rust

# Create two string slices with explicit lifetime annotations
// Your code here

Hint

Use &str type for string slices. Lifetime annotations are usually needed in function signatures, but here just declare the slices.

2

Add a function signature with lifetime annotations

Write a function called longest that takes two string slices with the same lifetime annotation &'a str and returns a string slice with the same lifetime &'a str. Only write the function signature (header) with lifetime annotations, without the body.

Rust

let string1: &str = "hello";
let string2: &str = "world";

// Write the function signature for `longest` with lifetime annotations
// Your code here

Hint

Use fn longest<'a>(x: &'a str, y: &'a str) -> &'a str to declare the function with lifetime 'a.

3

Implement the function body using lifetime annotations

Implement the body of the longest function. It should compare the lengths of x and y and return the longer string slice. Use the same lifetime annotations in the function signature and body.

Rust

let string1: &str = "hello";
let string2: &str = "world";

fn longest(x: &'a str, y: &'a str) -> &'a str {
    // Your code here
}

Hint

Use an if statement to compare lengths and return the longer slice.

4

Call the function and print the result

Call the longest function with string1 and string2 as arguments. Store the result in a variable called result and print it using println!.

Rust

let string1: &str = "hello";
let string2: &str = "world";

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

// Call longest and print the result
// Your code here

Hint

Use let result = longest(string1, string2); and println!("{}", result); to display the longest string.