Slice syntax in Rust - Cheat Sheet & Quick Revision

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. It does not own the data but borrows it, allowing safe access to parts of the collection.

beginner

How do you create a slice from an array in Rust?

You use the syntax &array[start..end] where start is inclusive and end is exclusive. For example, &arr[1..3] creates a slice of elements at index 1 and 2.

beginner

What does the slice syntax &arr[..] mean?

It means a slice of the entire array or collection. It borrows all elements from start to end.

intermediate

Explain the difference between &arr[2..] and &arr[..3].

&arr[2..] creates a slice from index 2 to the end of the array. &arr[..3] creates a slice from the start up to (but not including) index 3.

intermediate

Can you modify elements through a slice in Rust?

Yes, if the slice is mutable (e.g., &mut arr[1..4]), you can change the elements inside the slice. Otherwise, slices are read-only views.

What does the slice syntax &arr[1..4] represent?

A A slice from the start to index 4

B A slice from index 1 to index 4 inclusive

C A slice from index 1 up to but not including index 4

D A slice from index 4 to the end

In Rust, the range start..end includes start but excludes end.

How do you create a slice of the entire array arr?

A <code>&arr[..]</code>

B <code>&arr[0]</code>

C <code>&arr[1..]</code>

D <code>&arr[0..arr.len()]</code>

The syntax &arr[..] creates a slice of the whole array. Alternatively, &arr[0..arr.len()] also creates a slice of the entire array.

Which of these slices is mutable?

A <code>&mut arr[1..3]</code>

B <code>&arr[1..3]</code>

C <code>arr[1..3]</code>

D <code>arr[..]</code>

Only &mut arr[1..3] is a mutable slice, allowing modification of elements.

What happens if you try to create a slice with start greater than end like &arr[4..2]?

A It causes a runtime panic

B It causes a compile-time error

C It creates an empty slice

D It swaps the indices automatically

Rust panics at runtime if the start index is greater than the end index in a slice.

What type does a slice have in Rust?

A T

B &[T]

C Array<T>

D Vec<T>

A slice has the type &[T], a reference to a sequence of elements of type T.

Describe how to create and use slices in Rust, including syntax and mutability.

Think about how slices let you view parts of arrays safely.

Explain the difference between full slices, partial slices, and mutable slices in Rust.

Consider how slices relate to the original data and whether you can change it.

Practice

1. What does the slice syntax &array[2..5] mean in Rust?

easy

A. It creates a view of elements from index 2 up to but not including 5.

B. It copies elements from index 2 to 5 inclusive into a new array.

C. It creates a slice starting at index 5 and ending at index 2.

D. It returns the element at index 2 only.

Solution

1. Step 1: Understand slice range syntax

   The syntax start..end means from start index up to but not including end index.

2. Step 2: Apply to given slice

   So &array[2..5] means elements at indices 2, 3, and 4 are included in the slice.

3. Final Answer:

   It creates a view of elements from index 2 up to but not including 5. -> Option A

4. Quick Check:

   Slice range excludes end index = A [OK]

Hint: Remember slice excludes the end index, like half-open intervals [OK]

Common Mistakes:

• Thinking the slice copies elements instead of borrowing
• Including the end index element in the slice
• Confusing slice with single element access

2. Which of the following is the correct way to get a slice of the first 4 elements of an array named nums?

easy

A. &nums[1..4]

B. &nums[0..4]

C. &nums[0..5]

D. &nums[4..0]

Solution

1. Step 1: Identify slice start and end for first 4 elements

   The first 4 elements are at indices 0, 1, 2, and 3, so slice should start at 0 and end at 4 (exclusive).

2. Step 2: Check options for correct syntax

   &nums[0..4] uses &nums[0..4], which correctly slices elements 0 to 3.

3. Final Answer:

   &nums[0..4] -> Option B

4. Quick Check:

   Slice first 4 elements = &nums[0..4] [OK]

Hint: Start at 0, end at count for first N elements [OK]

Common Mistakes:

• Starting slice at 1 instead of 0
• Including one extra element by using end index too high
• Using reversed range which is invalid

3. What is the output of this Rust code?

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

medium

A. [20, 30, 40, 50]

B. [10, 20, 30, 40]

C. [20, 30, 40]

D. [30, 40, 50]

Solution

1. Step 1: Identify slice indices and elements

   The slice &arr[1..4] includes elements at indices 1, 2, and 3, which are 20, 30, and 40.

2. Step 2: Understand print output

   Printing the slice with {:?} shows the elements in array-like format.

3. Final Answer:

   [20, 30, 40] -> Option C

4. Quick Check:

   Slice arr[1..4] = [20, 30, 40] [OK]

Hint: Slice excludes end index, so count elements carefully [OK]

Common Mistakes:

• Including element at index 4 mistakenly
• Printing the whole array instead of slice
• Confusing slice with copying elements

4. What is wrong with this Rust code?

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

medium

A. The slice start index is greater than the end index, causing a panic.

B. The slice syntax is correct and will return an empty slice.

C. The code will compile but slice will contain elements 3 and 2.

D. The slice must use parentheses instead of brackets.

Solution

1. Step 1: Analyze slice indices order

   The slice &arr[3..2] has start index 3 and end index 2, which is invalid because start must be less than or equal to end.

2. Step 2: Understand Rust slice behavior

   Rust panics at runtime if slice start is greater than end; it does not return empty slice or reorder indices.

3. Final Answer:

   The slice start index is greater than the end index, causing a panic. -> Option A

4. Quick Check:

   Slice start > end causes panic [OK]

Hint: Slice start must be ≤ end; else panic occurs [OK]

Common Mistakes:

• Assuming reversed slice returns empty slice
• Thinking slice silently swaps indices
• Using parentheses instead of brackets for slices

5. Given a string let text = "hello world";, which slice expression extracts the word "world" correctly?

hard

A. &text[..5]

B. &text[5..10]

C. &text[6..10]

D. &text[6..]

Solution

1. Step 1: Identify indices of "world" in the string

   "hello world" has "world" starting at index 6 and goes to the end (index 10 inclusive).

2. Step 2: Check slice options

   &text[6..] uses &text[6..] which means from index 6 to the end, correctly extracting "world".

3. Final Answer:

   &text[6..] -> Option D

4. Quick Check:

   Slice from start index to end = &text[6..] [OK]

Hint: Use start.. to slice from start index to string end [OK]

Common Mistakes:

• Using wrong end index excluding last character
• Confusing byte indices with character indices (not in this example)
• Using slice that extracts wrong substring