Lifetime annotations in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function that returns a reference with the same lifetime as the input.

Rust

fn first_word<'a>(s: &'a str) -> &'a str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[0..s.len()]
}

Drag options to blanks, or click blank then click option'

A(

B[

C{

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses or braces instead of square brackets for slicing.

Forgetting to specify the range inside the brackets.

The correct syntax to create a slice reference is using square brackets []. So &s[0..i] returns a slice of the string.

2fill in blank

medium

Complete the function signature to specify that the returned reference has the same lifetime as the input reference.

Rust

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

Drag options to blanks, or click blank then click option'

A'a

B&

C&'a

D&'static

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the lifetime annotation in the return type.

Using &str without lifetime, which causes a compiler error.

The return type must be a reference with the same lifetime 'a as the input x, so &'a str is correct.

3fill in blank

hard

Fix the error in the function signature by adding the correct lifetime annotation.

Rust

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

Drag options to blanks, or click blank then click option'

A&'a

B&

C'a

D&'static

Attempts:

3 left

💡 Hint

Common Mistakes

Not adding lifetime parameters to the function signature.

Using &str without lifetime annotations in return type.

Without lifetime annotations, Rust cannot know how long the returned reference lives. Adding &'a ties the output lifetime to the inputs.

4fill in blank

hard

Fill both blanks to declare a struct with a lifetime parameter and a reference field using that lifetime.

Rust

struct ImportantExcerpt[1] {
    part: [2] str,
}

Drag options to blanks, or click blank then click option'

A<'a>

B&'a

Cstr

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add the lifetime parameter to the struct.

Using str instead of a reference type for the field.

The struct must declare a lifetime parameter <'a> and the field part must be a reference with that lifetime, &'a str.

5fill in blank

hard

Fill all three blanks to implement a method that returns the part field with the correct lifetime annotation.

Rust

impl[1] ImportantExcerpt[2] {
    fn level(&self) -> [3] str {
        self.part
    }
}

Drag options to blanks, or click blank then click option'

A<'a>

B&'a

C&str

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting lifetime parameters in impl block.

Returning str instead of &str from the method.

The impl block must specify the lifetime <'a>, the struct uses <'a>, and the method returns a reference &'a str tied to that lifetime.

Practice

1. What is the main purpose of lifetime annotations in Rust?

easy

A. To tell Rust how long references are valid

B. To specify variable types explicitly

C. To manage memory allocation manually

D. To define function return types only

Solution

1. Step 1: Understand lifetime annotations role

   Lifetime annotations tell Rust the scope of references to avoid dangling pointers.

2. Step 2: Compare with other options

   Other options describe unrelated concepts like type specification or memory management.

3. Final Answer:

   To tell Rust how long references are valid -> Option A

4. Quick Check:

   Lifetime annotations = reference validity [OK]

Hint: Lifetime annotations connect reference scopes [OK]

Common Mistakes:

• Confusing lifetimes with types
• Thinking lifetimes manage memory directly
• Assuming lifetimes only affect return types

2. Which of the following is the correct syntax to declare a lifetime parameter named 'a in a function signature?

easy

A. fn example(input: &'a str) -> str<'a>

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

C. fn example<'a>(input: &str<'a>) -> &str

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

Solution

1. Step 1: Identify correct lifetime syntax

   Lifetime parameters are declared with apostrophe before the name in angle brackets: 'a and used in references.

2. Step 2: Check each option

   fn example<'a>(input: &'a str) -> &'a str correctly declares 'a and uses it for input and output references. Others misuse syntax or place lifetime incorrectly.

3. Final Answer:

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

4. Quick Check:

   Lifetime syntax = fn example<'a>(input: &'a str) [OK]

Hint: Declare lifetimes in angle brackets before parameters [OK]

Common Mistakes:

• Placing lifetime after type instead of before
• Omitting lifetime declaration in angle brackets
• Using lifetime on non-reference types

3. What will be the output of this Rust code?

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("apple");
    let string2 = "banana";
    let result = longest(string1.as_str(), string2);
    println!("{}", result);
}

medium

A. Runtime error

B. apple

C. Compilation error due to lifetimes

D. banana

Solution

1. Step 1: Understand function longest behavior

   The function returns the longer string slice between x and y.

2. Step 2: Compare string lengths

   "apple" has 5 letters, "banana" has 6 letters, so "banana" is longer and returned.

3. Final Answer:

   banana -> Option D

4. Quick Check:

   Longest string = banana [OK]

Hint: Compare lengths to find longest string [OK]

Common Mistakes:

• Assuming compilation error due to lifetimes
• Confusing which string is longer
• Expecting runtime error from references

4. Identify the error in this Rust code snippet involving lifetimes:

fn first_word<'a>(s: &str) -> &'a str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

medium

A. Missing lifetime annotation on parameter s

B. Cannot return a slice of s without cloning

C. Return type lifetime 'a does not match input lifetime

D. Function should return String, not &str

Solution

1. Step 1: Check lifetime annotations on parameters and return

   The parameter s has no lifetime annotation, so Rust assigns an implicit lifetime. The return type has explicit lifetime 'a which is unrelated.

2. Step 2: Understand lifetime mismatch

   The return lifetime 'a must be tied to the input lifetime to ensure safety. Here, 'a is unrelated, causing a mismatch error.

3. Final Answer:

   Return type lifetime 'a does not match input lifetime -> Option C

4. Quick Check:

   Return lifetime must match input lifetime [OK]

Hint: Return lifetime must match input reference lifetime [OK]

Common Mistakes:

• Forgetting to add lifetime to input parameter
• Assuming cloning is needed for slices
• Confusing &str and String return types

5. Given two string slices with different lifetimes, how can you write a function that returns the longer slice safely using lifetime annotations? Choose the correct function signature.

hard

A. fn longest<'a>(x: &'a str, y: &'a str) -> &'a str

B. fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str

C. fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'b str

D. fn longest(x: &str, y: &str) -> &str

Solution

1. Step 1: Understand lifetime requirements for return

   The returned reference must be valid as long as both inputs. Using a single lifetime 'a for both inputs and output ensures this.

2. Step 2: Analyze options

   fn longest<'a>(x: &'a str, y: &'a str) -> &'a str uses one lifetime parameter for both inputs and output, guaranteeing safety. fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &'a str and C use different lifetimes, which can cause unsafe returns. fn longest(x: &str, y: &str) -> &str omits lifetimes, causing errors.

3. Final Answer:

   fn longest<'a>(x: &'a str, y: &'a str) -> &'a str -> Option A

4. Quick Check:

   Single lifetime for inputs and output [OK]

Hint: Use one lifetime for all references to ensure safety [OK]

Common Mistakes:

• Using different lifetimes for inputs and output
• Omitting lifetime annotations causing errors
• Assuming &str without lifetimes is enough