Learn Rust Coding · Lesson

Lifetimes for Safe References

Delve into lifetimes, Rust's mechanism for ensuring references are always valid and prevent dangling pointers at compile time.

Lifetimes for Safe References is a free Learn Rust Coding lesson on CoddyKit — lesson 3 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Learn Rust Coding learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Lifetimes Matter

Rust's ownership and borrowing rules prevent many common memory errors. But there's one more layer of safety: lifetimes.

Lifetimes ensure that references in your code always point to valid data. They solve the problem of dangling references, where a reference might point to memory that has already been deallocated.

The Dangling Pointer Risk

Imagine a scenario where a function creates data, returns a reference to it, and then the data is destroyed when the function ends. The returned reference would then point to invalid memory.

Rust uses lifetimes to prevent this at compile time. It checks that any reference you use will remain valid for as long as you need it, ensuring memory safety.

Rust Infers Lifetimes

You don't always need to write explicit lifetime annotations. Rust has a set of lifetime elision rules that allow the compiler to infer lifetimes in common patterns.

For example, in a function with one input reference, its lifetime is often automatically assigned to the output reference. This keeps your code cleaner!

When to Annotate

When Rust can't infer lifetimes, you must annotate them explicitly. This tells the compiler how the lifetimes of different references relate to each other.

The syntax for a lifetime annotation is an apostrophe followed by a lowercase letter, like 'a. It's a generic parameter for lifetimes, not a specific duration.

Function Lifetime Parameters

When a function takes multiple references and returns one, Rust needs to know which input reference's lifetime the output reference should have. This ensures the returned reference is always valid.

The <'a> syntax declares a generic lifetime parameter. Let's look at an example:

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("abcd");
  let string2 = "xyz";
  let result = longest(string1.as_str(), string2);
  println!("The longest string is: {}", result);
}

The 'static Lifetime

The 'static lifetime is a special case. It indicates that a reference can live for the entire duration of the program.

String literals (e.g., "hello world") have the 'static lifetime because they are stored directly in the program's binary and are available throughout execution.

fn main() {
  // 'static lifetime for a string literal
  let s: &'static str = "I live for the entire program!";
  println!("{}", s);

  // This is also implicitly 'static
  let another_s = "Hello from static land!";
  println!("{}", another_s);
}

Structs Holding References

If a struct holds a reference, you need to add a lifetime annotation to the struct's definition. This ensures that any instance of the struct doesn't outlive the data its references point to.

The lifetime parameter of the struct tells Rust that all references inside it must have at least that lifetime.

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

fn main() {
  let novel = String::from("Call me Ishmael. Some years ago...");
  let first_sentence = novel.split('.').next().expect("Could not find a '.'");
  let i = ImportantExcerpt {
    part: first_sentence,
  };
  println!("Excerpt part: {}", i.part);
}

Lifetimes with Generics

Lifetimes are a form of generics! You can combine them with type generics to create flexible and safe data structures or functions.

For example, a struct could hold references to generic types, all constrained by a single lifetime parameter, ensuring complex data relationships remain valid.

Decoding Compiler Errors

When you first encounter lifetime errors, they can seem intimidating. The most common error is "borrow might not live long enough".

This usually means you're trying to use a reference after the data it points to has been dropped, or that Rust can't prove its validity. Understanding these messages helps you adjust your lifetime annotations.

Quick Check: Lifetimes

Which of the following best describes the core problem that Rust's explicit lifetime annotations aim to solve?

Lifetimes: Compile-Time Safety

You've learned that lifetimes are a crucial part of Rust's memory safety guarantees. They prevent dangling references by ensuring that all references are valid for their entire usage.

Rust often infers lifetimes using elision rules.
You use explicit annotations like 'a when inference isn't possible.
Lifetimes are essential for functions returning references and for structs holding references.
The special 'static lifetime lasts for the program's entire duration.

Mastering lifetimes is key to writing robust Rust code!

Frequently asked questions

Is the “Lifetimes for Safe References” lesson free?

Yes — the full text of “Lifetimes for Safe References” is free to read here on the web, and the Learn Rust Coding course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Learn Rust Coding course, upgrade to CoddyKit PRO.

What will I learn in “Lifetimes for Safe References”?

Delve into lifetimes, Rust's mechanism for ensuring references are always valid and prevent dangling pointers at compile time. You practise Learn Rust Coding with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Learn Rust Coding?

No prior experience is required. Learn Rust Coding on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Lifetimes for Safe References” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Learn Rust Coding lesson?

Yes. Every Learn Rust Coding lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Learn Rust Coding