Why slices are used in Rust - Quick Recap

Recall & Review

beginner

What is a slice in Rust?

A slice is a view into a contiguous sequence of elements in a collection, like an array or vector, without owning the data.

beginner

Why do we use slices instead of copying data in Rust?

Slices let us access parts of data without copying it, saving memory and improving performance.

intermediate

How do slices help with safety in Rust?

Slices keep track of their length and prevent out-of-bounds access, helping avoid bugs and crashes.

intermediate

Can slices be modified in Rust?

Mutable slices (&mut [T]) allow changing the data they point to, while immutable slices (&[T]) only allow reading.

beginner

Give a real-life example of why slices are useful.

Like looking at a part of a book without copying pages, slices let programs look at parts of data without making new copies.

What does a slice in Rust represent?

A A full copy of an array

B A reference to a part of a collection without owning it

C A new vector with copied data

D A pointer to a single element only

Slices are references to parts of collections without owning the data.

Why are slices preferred over copying data?

A They use less memory and are faster

B They create new data copies

C They slow down the program

D They remove data from memory

Slices avoid copying, saving memory and improving speed.

Which of these is true about Rust slices?

A They keep track of length to prevent errors

B They allow out-of-bounds access

C They always own the data

D They cannot be mutable

Slices store length and prevent out-of-bounds access for safety.

What type of slice allows modifying the data it points to?

A Vec<T>

B &[T]

C &mut [T]

D Box<T>

Mutable slices (&mut [T]) allow changing the data.

Which analogy best describes a slice?

A Writing a new book from scratch

B Making a photocopy of the whole book

C Throwing away pages from a book

D Looking at a part of a book without copying pages

Slices let you view part of data without copying, like reading part of a book.

Explain why slices are used in Rust and how they help with memory and safety.

Think about how slices let you look at data without owning or copying it.

Describe the difference between mutable and immutable slices in Rust.

Consider how you can or cannot change data through slices.

Practice

1. Why are slices used in Rust?
let arr = [1, 2, 3, 4]; let slice = &arr[1..3];

easy

A. To access a part of a collection without copying the data

B. To create a new independent array from the original

C. To permanently delete elements from the array

D. To convert an array into a string

Solution

1. Step 1: Understand what a slice does

   A slice is a reference to a part of a collection, like a section of an array, without copying the data.

2. Step 2: Analyze the example code

   The code &arr[1..3] creates a slice referencing elements at index 1 and 2, not a new array or deletion.

3. Final Answer:

   To access a part of a collection without copying the data -> Option A

4. Quick Check:

   Slices = references to parts of collections [OK]

Hint: Slices reference parts without copying data [OK]

Common Mistakes:

• Thinking slices copy data
• Confusing slices with new arrays
• Assuming slices delete elements

2. Which of the following is the correct syntax to create a slice of the first three elements of an array arr in Rust?

easy

A. let slice = arr[0..3];

B. let slice = arr[0, 3];

C. let slice = arr.slice(0, 3);

D. let slice = &arr[0..3];

Solution

1. Step 1: Recall slice syntax in Rust

   Rust slices are references, so you must use & before the range to create a slice.

2. Step 2: Check each option

   let slice = &arr[0..3]; uses &arr[0..3], which is the correct syntax. let slice = arr[0..3]; misses the reference, B uses invalid syntax, and C uses a non-existent method.

3. Final Answer:

   let slice = &arr[0..3]; -> Option D

4. Quick Check:

   Slice syntax = &array[start..end] [OK]

Hint: Slices need & before range to reference data [OK]

Common Mistakes:

• Omitting & before the slice range
• Using invalid methods like slice()
• Using comma instead of range syntax

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

let arr = [10, 20, 30, 40, 50];
let slice = &arr[2..4];
println!("{:?}", slice);

medium

A. [30, 40]

B. [20, 30]

C. [30, 40, 50]

D. [10, 20]

Solution

1. Step 1: Understand the slice range

   The slice &arr[2..4] includes elements at index 2 and 3 (end index 4 is exclusive).

2. Step 2: Identify elements at those indices

   Index 2 is 30, index 3 is 40, so the slice contains [30, 40].

3. Final Answer:

   [30, 40] -> Option A

4. Quick Check:

   Slice range excludes end index [OK]

Hint: Slice end index is exclusive, so stop before it [OK]

Common Mistakes:

• Including the end index element
• Confusing indices with values
• Printing the whole array instead of slice

4. Find the error in this Rust code that tries to create a slice:

let arr = [1, 2, 3, 4];
let slice = arr[1..5];

medium

A. Array declaration syntax is wrong

B. Slice range is out of bounds and missing reference operator

C. Slice syntax is correct, no error

D. Slice must use parentheses instead of brackets

Solution

1. Step 1: Check the slice range validity

   The array has length 4, so index 5 is out of bounds causing an error.

2. Step 2: Check slice syntax

   The code misses the & reference operator needed to create a slice.

3. Final Answer:

   Slice range is out of bounds and missing reference operator -> Option B

4. Quick Check:

   Slice must be &array[start..end] within bounds [OK]

Hint: Slice must be referenced and within array bounds [OK]

Common Mistakes:

• Ignoring out of bounds index
• Forgetting & before slice
• Thinking brackets are wrong syntax

5. You want to write a function that takes a string slice and prints its first 3 characters safely. Which function signature and usage is correct in Rust?

hard

A. fn print_first_three(s: String) { println!("{}", &s[0..3]); }

B. fn print_first_three(s: &String) { println!("{}", s[0..3]); }

C. fn print_first_three(s: &str) { println!("{}", &s[0..3]); }

D. fn print_first_three(s: &str) { println!("{}", s[0..3]); }

Solution

1. Step 1: Understand string slices and indexing

   String slices &str are references to string data and support slicing with range syntax and & to get a slice.

2. Step 2: Analyze each function signature and usage

   fn print_first_three(s: &str) { println!("{}", &s[0..3]); } correctly takes &str and slices with &s[0..3]. fn print_first_three(s: String) { println!("{}", &s[0..3]); } takes ownership (String) but slices correctly. fn print_first_three(s: &String) { println!("{}", s[0..3]); } misses & before slice. fn print_first_three(s: &str) { println!("{}", s[0..3]); } slices without &, causing error.

3. Final Answer:

   fn print_first_three(s: &str) { println!("{}", &s[0..3]); } -> Option C

4. Quick Check:

   Use &str and &s[start..end] for safe string slices [OK]

Hint: Use &str and &s[start..end] to slice strings safely [OK]

Common Mistakes:

• Using String instead of &str for slicing
• Omitting & before slice range
• Trying to slice without reference