Why slices are used in Rust - The Real Reasons

The Big Idea

What if you could handle just the part you need without carrying the whole load every time?

The Scenario

Imagine you have a big book and you want to share just a few pages with a friend without copying the whole book.

The Problem

Copying those pages by hand takes time and space. If you want to change something, you must copy again. This wastes effort and memory.

The Solution

Slices let you point to just the pages you want inside the big book without copying. You can read or use those pages quickly and safely.

Before vs After

✗ Before

let part = vec![1, 2, 3, 4, 5]; let copy = part.clone();

✓ After

let part = vec![1, 2, 3, 4, 5]; let slice = &part[1..4];

What It Enables

Slices let you work with parts of data efficiently, saving memory and speeding up your programs.

Real Life Example

When playing a song, you might want to process just a small segment of the audio without loading the entire track again.

Key Takeaways

Slices avoid unnecessary copying of data.

They provide safe, fast access to parts of collections.

Using slices makes programs more efficient and easier to manage.

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