Slice lifetime basics in Rust - Mini Project: Build & Apply

Slice lifetime basics

📖 Scenario: Imagine you have a list of your favorite fruits stored in a Rust program. You want to create a smaller view (slice) of this list to work with only some fruits without copying the whole list.

🎯 Goal: You will create a slice from a list of fruits and learn how to use lifetimes to make sure the slice is valid as long as the original list exists.

📋 What You'll Learn

Create a vector of fruits

Create a slice that borrows part of the vector

Use a lifetime annotation to tie the slice's lifetime to the vector

Print the slice contents

💡 Why This Matters

🌍 Real World

Slices let you work with parts of data without copying, saving memory and time. This is useful in programs that handle large lists or strings.

💼 Career

Understanding lifetimes and slices is essential for safe and efficient Rust programming, a skill valued in systems programming, embedded development, and performance-critical applications.

1

Create a vector of fruits

Create a vector called fruits with these exact string values: "Apple", "Banana", "Cherry", "Date", "Elderberry".

Rust

# Create a vector called fruits with the given fruit names
# Your code here

Hint

Use vec![...] to create a vector with the exact fruit names inside double quotes.

2

Create a slice of the fruits vector

Create a slice called fruit_slice that borrows the second to fourth fruits from fruits using slicing syntax &fruits[1..4].

Rust

fn main() {
    let fruits = vec!["Apple", "Banana", "Cherry", "Date", "Elderberry"];
    
    // Create a slice called fruit_slice borrowing fruits from index 1 to 3
    // Your code here
}

Hint

Use &fruits[1..4] to borrow a slice from the vector.

3

Add a function with lifetime annotation

Write a function called print_slice that takes a slice of strings with a lifetime 'a as input: &'a [&str] and prints each fruit. Use for fruit in input to loop over the slice.

Rust

// Define a function print_slice with lifetime 'a that takes input: &'a [&str]
// and prints each fruit
// Your code here

fn main() {
    let fruits = vec!["Apple", "Banana", "Cherry", "Date", "Elderberry"];
    let fruit_slice = &fruits[1..4];
}

Hint

Use fn print_slice<'a>(input: &'a [&str]) to declare the function with lifetime. Use a for loop to print each fruit.

4

Call the function and print the slice

Call the function print_slice with fruit_slice inside main to print the fruits in the slice.

Rust

fn print_slice(input: &'a [&str]) {
    for fruit in input {
        println!("{}", fruit);
    }
}

fn main() {
    let fruits = vec!["Apple", "Banana", "Cherry", "Date", "Elderberry"];
    let fruit_slice = &fruits[1..4];

    // Call print_slice with fruit_slice
    // Your code here
}

Hint

Call print_slice(fruit_slice); inside main to print the slice.

Practice

1. What does a slice lifetime in Rust indicate?
fn example<'a>(slice: &'a [i32]) {}

easy

A. How long the slice reference is valid in the program

B. The size of the slice in memory

C. The number of elements in the slice

D. The type of elements inside the slice

Solution

1. Step 1: Understand what a lifetime means in Rust

   Lifetimes tell Rust how long a reference is valid to prevent using invalid data.

2. Step 2: Apply this to a slice reference

   The lifetime on a slice reference means how long the slice can be safely used.

3. Final Answer:

   How long the slice reference is valid in the program -> Option A

4. Quick Check:

   Slice lifetime = reference validity [OK]

Hint: Lifetimes track reference validity duration [OK]

Common Mistakes:

• Confusing lifetime with size or length
• Thinking lifetime is about element type
• Ignoring lifetime annotations on references

2. Which of the following is the correct syntax to declare a function that takes a slice with a lifetime parameter?

fn process_slice(____) {}

easy

A. &'a [i32]

B. &'a [i32];

C. &[i32]

D. &[i32]'a

Solution

1. Step 1: Recall lifetime syntax for references

   Lifetimes are written as &'a before the type to indicate the lifetime of the reference.

2. Step 2: Check each option

   &'a [i32] correctly places &'a before the slice type [i32]. &[i32] misses lifetime, &'a [i32]; has an extra semicolon, &[i32]'a places lifetime incorrectly.

3. Final Answer:

   &'a [i32] -> Option A

4. Quick Check:

   Lifetime syntax = &'a [type] [OK]

Hint: Lifetimes go right after & before type [OK]

Common Mistakes:

• Putting lifetime after the type
• Adding extra semicolons inside parameters
• Omitting lifetime when needed

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

fn get_first<'a>(slice: &'a [i32]) -> &'a i32 {
    &slice[0]
}

fn main() {
    let numbers = vec![10, 20, 30];
    let first = get_first(&numbers);
    println!("{}", first);
}

medium

A. 20

B. 10

C. Compilation error due to lifetime mismatch

D. Runtime panic

Solution

1. Step 1: Understand the function behavior

   The function returns a reference to the first element of the slice, which is 10.

2. Step 2: Check lifetime correctness and usage

   The lifetime 'a ensures the returned reference is valid as long as the input slice is valid. The vector lives long enough, so no error.

3. Final Answer:

   10 -> Option B

4. Quick Check:

   Returned first element = 10 [OK]

Hint: Returned slice element matches first index [OK]

Common Mistakes:

• Thinking lifetime causes compile error here
• Confusing element values
• Expecting runtime panic without reason

4. Identify the error in this Rust code snippet:

fn invalid<'a>() -> &'a [i32] {
    let data = vec![1, 2, 3];
    &data[..]
}

medium

A. Missing lifetime annotation on data

B. Syntax error in slice syntax

C. The function returns a reference to data that will be dropped

D. No error, code is correct

Solution

1. Step 1: Analyze the function return and data lifetime

   The function returns a slice reference with lifetime 'a, but data is created inside the function and dropped when it ends.

2. Step 2: Understand why this causes an error

   Returning a reference to local data is invalid because the data won't live long enough, causing a dangling reference.

3. Final Answer:

   The function returns a reference to data that will be dropped -> Option C

4. Quick Check:

   Returning local reference = error [OK]

Hint: Never return reference to local variable [OK]

Common Mistakes:

• Assuming lifetime annotation fixes local data drop
• Ignoring ownership rules
• Thinking slice syntax is wrong

5. Given this function that returns a slice from two input slices, which lifetime annotation is correct to ensure safety?

fn longest_slice<'a>(x: &'a [i32], y: &'a [i32]) -> &____ [i32] {
    if x.len() > y.len() { x } else { y }
}

hard

A. 'a + 'b

B. 'b

C. 'static

D. 'a

Solution

1. Step 1: Understand the function's return lifetime

   The function returns a slice that could come from either input slice, both sharing lifetime 'a.

2. Step 2: Use shared lifetime for safety

   The correct lifetime for the return is 'a, matching the lifetime of both input slices.

3. Final Answer:

   'a -> Option D

4. Quick Check:

   Return lifetime = 'a of inputs [OK]

Hint: Return lifetime must cover both inputs [OK]

Common Mistakes:

• Choosing only one input lifetime
• Using 'static without reason
• Ignoring lifetime intersection rules