Lifetimes in functions in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a lifetime in Rust?

A lifetime is a way Rust keeps track of how long references are valid to prevent dangling pointers and ensure memory safety.

intermediate

Why do functions sometimes need explicit lifetime annotations?

Because Rust needs help to understand how the lifetimes of input references relate to the output references, ensuring safe borrowing.

beginner

What does the syntax &'a str mean in a function parameter?

It means the function takes a string slice reference that lives at least as long as the lifetime 'a, which is a named lifetime parameter.

intermediate

Explain this function signature: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str

It means the function takes two string slices that live at least as long as 'a and returns a string slice that also lives at least as long as 'a, tying input and output lifetimes together.

intermediate

What happens if you omit lifetime annotations in a function with multiple references?

Rust may give a compile error because it can't infer how the lifetimes relate, so you need to add explicit lifetime annotations to clarify.

What is the main purpose of lifetimes in Rust functions?

A To allocate memory on the heap

B To speed up the program execution

C To ensure references do not outlive the data they point to

D To define variable types

Lifetimes ensure references are valid only as long as the data they refer to, preventing unsafe memory access.

In the function signature fn foo<'a>(x: &'a i32) -> &'a i32, what does 'a represent?

A A named lifetime parameter linking input and output lifetimes

B A generic type parameter

C A variable name

D A constant value

The 'a is a lifetime parameter that tells Rust the output reference lives at least as long as the input reference.

If a function returns a reference to one of its input parameters, what must you do?

A Use the <code>mut</code> keyword

B Add lifetime annotations to link input and output lifetimes

C Return an owned value instead

D Nothing, Rust infers it automatically always

Rust needs explicit lifetime annotations to know which input lifetime the output reference is tied to.

What error might you see if you forget lifetime annotations in a function with multiple references?

A Missing lifetime specifier error

B Type mismatch error

C Syntax error

D Stack overflow

Rust will complain about missing lifetime specifiers because it can't infer how lifetimes relate.

Which of these is a valid lifetime annotation in a function signature?

A fn example(x: str<'a>) -> str<'a>

B fn example(x: &str) -> &str<'a>

C fn example<'a>(x: str) -> str

D fn example<'a>(x: &'a str) -> &'a str

The correct syntax places the lifetime parameter before the function parameters and uses it with references.

Explain why Rust requires lifetime annotations in some function signatures and how they help with memory safety.

Think about how Rust prevents dangling references.

Describe the meaning of this function signature: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str.

Focus on how the lifetime 'a connects inputs and output.