Why slices are used in Rust - Why It Works This Way

Overview - Why slices are used

What is it?

Slices in Rust are a way to view a part of a collection, like a piece of an array or string, without copying the data. They let you work with a section of data safely and efficiently by referencing it. Slices have a fixed size known at runtime and provide read-only or mutable access to the data they point to. This helps avoid unnecessary copying and keeps programs fast and memory-friendly.

Why it matters

Without slices, you would often need to copy parts of data to work on them, which wastes memory and slows down programs. Slices let you borrow just the part you need, making your code faster and more efficient. They also help prevent bugs by enforcing safe access rules, so you don't accidentally change or read data you shouldn't. This makes Rust programs both safe and speedy.

Where it fits

Before learning slices, you should understand Rust's ownership and borrowing rules, as slices rely on borrowing data safely. After slices, you can explore more advanced topics like iterators, string handling, and smart pointers, which build on the idea of safely accessing data without copying.

Mental Model

Core Idea

A slice is a safe, lightweight window into a part of a collection that lets you access data without copying it.

Think of it like...

Imagine a slice like a bookmark in a book that points to a specific chapter or page range. You don't carry the whole book around again; you just refer to the part you want to read.

Array: [10, 20, 30, 40, 50]
Slice:       └───────┘
Indexes:      1       3

Slice points to elements 20, 30, and 40 without copying them.

Build-Up - 7 Steps

1

Foundation

Understanding Rust Arrays

Concept: Learn what arrays are and how they store data in Rust.

An array in Rust is a fixed-size list of elements of the same type stored contiguously in memory. For example, let arr = [1, 2, 3, 4, 5]; creates an array of five integers. Arrays have a fixed size known at compile time.

Result

You can store and access multiple values in a single variable using an array.

Knowing arrays helps you understand the data structures slices will reference without copying.

2

Foundation

Introduction to Borrowing

Concept: Learn how Rust lets you borrow data safely without taking ownership.

Rust's borrowing rules let you create references to data without moving or copying it. For example, let ref_to_arr = &arr; borrows the whole array. Borrowing ensures data safety by preventing simultaneous mutable and immutable access.

Result

You can access data through references without owning or copying it.

Borrowing is the foundation that makes slices safe and efficient.

3

Intermediate

What Is a Slice in Rust?

Concept: Introduce slices as references to parts of collections.

A slice is a reference to a contiguous sequence of elements in a collection, like an array or vector. For example, let slice = &arr[1..4]; creates a slice pointing to elements at indexes 1, 2, and 3. Slices do not own data; they borrow it.

Result

You get a view into part of the data without copying it.

Slices let you work with parts of data efficiently and safely by borrowing.

4

Intermediate

Immutable vs Mutable Slices

Concept: Learn the difference between read-only and writable slices.

Slices can be immutable (&[T]) or mutable (&mut [T]). Immutable slices let you read data but not change it. Mutable slices let you modify the data they point to, but Rust enforces that only one mutable reference exists at a time to prevent conflicts.

Result

You can safely read or modify parts of data depending on the slice type.

Understanding slice mutability helps prevent bugs and data races.

5

Intermediate

Slices with Strings

Concept: Explore how slices work with strings in Rust.

Strings in Rust are UTF-8 encoded and stored as a sequence of bytes. String slices (&str) let you view parts of a string without copying. For example, let s = "hello"; let slice = &s[1..4]; points to "ell". String slices are always valid UTF-8 sequences.

Result

You can efficiently work with parts of text without copying or reallocating.

String slices combine safety and efficiency for text processing.

6

Advanced

Why Slices Avoid Copying Data

🤔Before reading on: do you think slices copy data or just reference it? Commit to your answer.

Concept: Understand how slices provide views without duplicating data in memory.

Slices store a pointer to the start of the data and a length, but do not own or copy the data. This means creating a slice is cheap and fast. The Rust compiler enforces borrowing rules to ensure the original data lives long enough for the slice to be valid.

Result

Using slices avoids unnecessary memory use and speeds up programs.

Knowing slices don't copy data explains why they are so efficient and safe.

7

Expert

Slices and Rust's Safety Guarantees

🤔Quick: Can a slice outlive the data it points to? Commit yes or no.

Concept: Learn how Rust's lifetime system ensures slices never become invalid references.

Rust uses lifetimes to track how long references, including slices, are valid. The compiler checks that slices cannot outlive the data they borrow. This prevents dangling pointers and memory safety bugs common in other languages. Lifetimes are implicit in most cases but can be explicitly annotated for complex scenarios.

Result

Slices are guaranteed safe to use without runtime checks or crashes.

Understanding lifetimes reveals how Rust enforces memory safety with zero-cost abstractions like slices.

Under the Hood

Slices are implemented as a fat pointer: a pair consisting of a pointer to the data's start and a length. This allows the slice to know exactly which part of the data it references. At runtime, no data is copied; the slice just accesses the original memory. The Rust compiler uses lifetimes to ensure the slice cannot outlive the data it points to, preventing invalid memory access.

Why designed this way?

Rust was designed to provide memory safety without sacrificing performance. Slices allow efficient access to parts of data without copying, which is common in other languages but costly. The fat pointer design balances flexibility and speed. Lifetimes and borrowing rules enforce safety at compile time, avoiding runtime overhead and bugs.

┌───────────────┐
│ Original Data │
│ [10, 20, 30, 40, 50] │
└───────┬───────┘
        │
        ▼
┌───────────────────────────┐
│ Slice (fat pointer)       │
│ Pointer -> data[1] (20)   │
│ Length -> 3               │
└───────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do slices own the data they point to? Commit yes or no.

Common Belief: Slices own the data they reference, so they manage memory.

Reality: Slices only borrow data; they do not own or free it.

Why it matters: Thinking slices own data can lead to double frees or use-after-free bugs.

Quick: Can you create a slice that outlives the original data? Commit yes or no.

Common Belief: You can create slices that live longer than the data they point to.

Reality: Rust's lifetime system prevents slices from outliving their data at compile time.

Why it matters: Ignoring this causes dangling pointer bugs in other languages; Rust prevents this entirely.

Quick: Do slices always copy data when created? Commit yes or no.

Common Belief: Slices copy the part of the data they reference to a new location.

Reality: Slices only create a reference; no copying happens.

Why it matters: Believing slices copy data can lead to inefficient code or misunderstanding performance.

Quick: Are mutable and immutable slices allowed simultaneously? Commit yes or no.

Common Belief: You can have both mutable and immutable slices to the same data at the same time.

Reality: Rust forbids simultaneous mutable and immutable slices to prevent data races.

Why it matters: Ignoring this can cause subtle bugs and undefined behavior in concurrent code.

Expert Zone

1

Slices are zero-cost abstractions: they add no runtime overhead compared to raw pointers but provide safety guarantees.

2

The fat pointer structure of slices allows Rust to handle dynamically sized types efficiently, a key feature for generic programming.

3

Explicit lifetime annotations with slices can clarify complex borrowing scenarios, improving code readability and compiler error messages.

When NOT to use

Slices are not suitable when you need ownership or to store data beyond the lifetime of the original collection. In such cases, use owned types like Vec or String. Also, slices cannot represent non-contiguous data; for that, consider other data structures like linked lists or iterators.

Production Patterns

In real-world Rust code, slices are used extensively for function parameters to accept any part of a collection without copying. They enable writing generic, efficient libraries and APIs. For example, sorting functions take slices to sort parts of arrays or vectors. String slices (&str) are the standard way to handle text input and output safely.

Connections

Pointers in C/C++

Slices build on the idea of pointers but add safety and length information.

Understanding slices helps appreciate how Rust prevents common pointer bugs like buffer overflows and dangling pointers.

Views in Databases

Slices are like database views that show a subset of data without copying it.

Knowing slices as views helps understand efficient data access patterns in software and databases.

Memory Safety in Operating Systems

Slices enforce memory safety rules similar to how OSes protect memory regions.

Recognizing this connection shows how Rust's design brings system-level safety guarantees to everyday programming.

Common Pitfalls

#1 Trying to use a slice after the original data is dropped.

Wrong approach:

let slice;
{
let v = vec![1, 2, 3];
slice = &v[0..2];
}
println!("{:?}", slice);

Correct approach:

let v = vec![1, 2, 3];
let slice = &v[0..2];
println!("{:?}", slice);

Root cause:

The slice references data that no longer exists because the vector was dropped, causing a dangling reference.

#2 Creating overlapping mutable and immutable slices to the same data.

Wrong approach:

let mut arr = [1, 2, 3];
let slice1 = &arr[0..2];
let slice2 = &mut arr[1..3];

Correct approach:

let mut arr = [1, 2, 3];
let slice1 = &arr[0..1];
let slice2 = &mut arr[1..3];

Root cause:

Rust forbids mutable and immutable borrows overlapping to prevent data races and undefined behavior.

#3 Assuming slices copy data when passed to functions.

Wrong approach:

fn process(slice: &[i32]) {
// ...
}
let arr = [1, 2, 3];
process(arr[0..3].to_vec()); // unnecessary copying

Correct approach:

fn process(slice: &[i32]) {
// ...
}
let arr = [1, 2, 3];
process(&arr[0..3]); // no copying

Root cause:

Misunderstanding that slices are references leads to inefficient code by copying unnecessarily.

Key Takeaways

Slices provide a safe, efficient way to access parts of collections without copying data.

They rely on Rust's borrowing and lifetime system to guarantee memory safety at compile time.

Slices are implemented as fat pointers containing a data pointer and length, enabling dynamic size handling.

Understanding slices is essential for writing fast, safe, and idiomatic Rust code.

Misusing slices can lead to common bugs, but Rust's compiler helps prevent these mistakes early.

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