Array basics in Rust - Deep Dive

Overview - Array basics

What is it?

An array in Rust is a collection of items of the same type stored in a fixed-size sequence. Each item in the array can be accessed by its position, called an index, starting from zero. Arrays are useful when you know exactly how many elements you want to store and want fast access to them. They are stored on the stack, which makes them very efficient.

Why it matters

Arrays exist to organize multiple values under one name, making it easier to manage and use data together. Without arrays, you would have to create separate variables for each value, which is inefficient and error-prone. Arrays allow programs to handle lists of data, like scores, names, or measurements, in a neat and fast way.

Where it fits

Before learning arrays, you should understand basic variables and data types in Rust. After arrays, you can learn about vectors, which are like arrays but can change size, and slices, which let you work with parts of arrays.

Mental Model

Core Idea

An array is like a row of mailboxes, each holding one item, all lined up and numbered so you can quickly find any item by its position.

Think of it like...

Imagine a row of identical mailboxes on a street, each with a number starting from zero. You can put a letter in any mailbox or take it out by knowing its number. The mailboxes are fixed in number and order, just like an array's elements.

Array (fixed size, same type)
┌─────┬─────┬─────┬─────┐
│[0]  │[1]  │[2]  │[3]  │
│val0 │val1 │val2 │val3 │
└─────┴─────┴─────┴─────┘

Build-Up - 7 Steps

1

Foundation

Declaring a fixed-size array

Concept: How to create an array with a fixed number of elements of the same type.

let numbers: [i32; 4] = [10, 20, 30, 40]; // This creates an array named 'numbers' with 4 integers.

Result

An array named 'numbers' holding the values 10, 20, 30, and 40.

Understanding the syntax for fixed-size arrays is the first step to organizing multiple values efficiently.

2

Foundation

Accessing array elements by index

Concept: How to get or use a specific item in an array using its position number.

let first = numbers[0]; let second = numbers[1]; // Accesses the first and second elements of the array.

Result

first is 10, second is 20.

Knowing that array positions start at zero helps avoid common off-by-one errors.

3

Intermediate

Arrays have fixed size and type

🤔Before reading on: Do you think you can add more items to an array after creating it? Commit to yes or no.

Concept: Arrays cannot change size after creation, and all elements must be the same type.

let mut arr = [1, 2, 3]; // arr.push(4); // This will cause a compile error because arrays have fixed size. // Also, all elements must be the same type: // let arr = [1, "two", 3]; // This is invalid.

Result

Trying to add elements or mix types causes compile errors.

Understanding fixed size and uniform type prevents runtime errors and helps choose the right data structure.

4

Intermediate

Using array length and iteration

🤔Before reading on: Do you think arrays have a built-in way to find how many items they hold? Commit to yes or no.

Concept: Arrays have a length property and can be looped over to process each element.

let arr = [5, 10, 15]; println!("Length: {}", arr.len()); for val in arr.iter() { println!("Value: {}", val); }

Result

Prints length 3 and each value on its own line.

Knowing how to get array size and loop through elements is essential for working with collections.

5

Intermediate

Arrays vs slices: borrowing parts

🤔Before reading on: Can you use part of an array without copying it? Commit to yes or no.

Concept: Slices let you borrow a part of an array without copying, useful for efficient data handling.

let arr = [1, 2, 3, 4, 5]; let slice = &arr[1..4]; // slice contains elements at positions 1, 2, and 3. for val in slice { println!("Slice value: {}", val); }

Result

Prints 2, 3, and 4 without copying the array.

Understanding slices helps manage memory efficiently and work with parts of arrays safely.

6

Advanced

Arrays on stack and memory implications

🤔Before reading on: Do you think arrays are stored on the heap or stack? Commit to your answer.

Concept: Arrays are stored on the stack, which makes access fast but size fixed at compile time.

In Rust, fixed-size arrays are stored on the stack. This means their size must be known at compile time, and accessing elements is very fast because the memory is contiguous and local. Large arrays can cause stack overflow, so for big or dynamic data, vectors are preferred.

Result

Arrays provide fast access but limited flexibility due to stack storage.

Knowing where arrays live in memory helps choose the right data structure for performance and safety.

7

Expert

Array type signature and compiler checks

🤔Before reading on: Does Rust treat arrays with different sizes as the same type? Commit to yes or no.

Concept: In Rust, arrays with different sizes are different types, enabling compile-time size checks.

let a: [i32; 3] = [1, 2, 3]; let b: [i32; 4] = [4, 5, 6, 7]; // a and b have different types because their sizes differ. // This prevents mixing arrays of different lengths accidentally. fn takes_three(arr: [i32; 3]) { // function expects exactly 3 elements } // takes_three(b); // This will not compile.

Result

Compile errors prevent passing arrays of wrong size, increasing safety.

Understanding that array size is part of the type unlocks Rust's powerful safety guarantees and prevents bugs.

Under the Hood

Rust arrays are stored as contiguous blocks of memory on the stack. Each element occupies a fixed amount of space based on its type. The compiler knows the array's size at compile time, so it can calculate the exact memory layout and enforce type and size safety. Accessing an element uses pointer arithmetic to jump to the correct memory offset quickly. Because arrays are fixed size, no extra metadata is needed at runtime.

Why designed this way?

Rust's design emphasizes safety and performance. By making array size part of the type and storing arrays on the stack, Rust ensures fast access and compile-time checks that prevent common bugs like buffer overflows. Alternatives like heap-allocated vectors offer flexibility but with runtime cost. This design balances speed, safety, and predictability.

Stack Memory Layout
┌───────────────┐
│ arr[0] value  │
├───────────────┤
│ arr[1] value  │
├───────────────┤
│ arr[2] value  │
├───────────────┤
│ arr[3] value  │
└───────────────┘

Type system enforces: [i32; 4] ≠ [i32; 3]

Access: base_address + index * size_of_element

Myth Busters - 4 Common Misconceptions

Quick: Can you add elements to a Rust array after creation? Commit to yes or no.

Common Belief: Arrays in Rust can grow or shrink like lists in other languages.

Reality: Rust arrays have a fixed size that cannot change after creation.

Why it matters: Trying to resize arrays causes compile errors and confusion; using vectors is the correct approach for dynamic collections.

Quick: Are arrays and slices the same thing in Rust? Commit to yes or no.

Common Belief: Slices are just another name for arrays.

Reality: Slices are views into arrays or other collections; they borrow parts without owning data and have dynamic size.

Why it matters: Confusing slices with arrays can lead to ownership and borrowing mistakes, causing bugs or compile errors.

Quick: Does Rust treat arrays of different lengths as the same type? Commit to yes or no.

Common Belief: All arrays of the same element type are the same type regardless of length.

Reality: Arrays with different lengths are different types in Rust, enforced at compile time.

Why it matters: This prevents mixing arrays of different sizes accidentally, increasing safety but requiring explicit handling.

Quick: Are Rust arrays stored on the heap by default? Commit to yes or no.

Common Belief: Arrays are stored on the heap like vectors for flexibility.

Reality: Fixed-size arrays are stored on the stack, which is faster but size-limited.

Why it matters: Misunderstanding storage location can cause performance surprises or stack overflow errors with large arrays.

Expert Zone

1

Array size is part of the type, enabling powerful compile-time checks and optimizations.

2

Arrays are Copy if their elements are Copy, allowing cheap duplication without heap allocation.

3

Pattern matching can destructure arrays by size, but only if the size is known at compile time.

When NOT to use

Use arrays only when the size is fixed and known at compile time. For collections that need to grow, shrink, or have unknown size, use vectors (Vec) instead. For borrowed views into arrays or vectors, use slices (&[T]).

Production Patterns

Arrays are commonly used for fixed-size buffers, lookup tables, or when interfacing with hardware or C code requiring fixed memory layout. They are also used in performance-critical code where stack allocation and predictable size matter.

Connections

Vectors (Vec<T>)

Vectors build on arrays by allowing dynamic resizing and heap storage.

Understanding arrays clarifies why vectors need heap allocation and how they manage flexible sizes safely.

Memory management

Arrays illustrate stack allocation and fixed-size memory layout.

Knowing how arrays live on the stack helps understand Rust's ownership and borrowing rules for safe memory use.

Database fixed-length records

Arrays and fixed-length database records both store fixed-size, ordered data efficiently.

Recognizing this connection helps appreciate why fixed-size data structures are fast and predictable in many systems.

Common Pitfalls

#1 Trying to add elements to an array after creation.

Wrong approach:

let mut arr = [1, 2, 3];
arr.push(4);

Correct approach:

let mut vec = vec![1, 2, 3];
vec.push(4);

Root cause:

Confusing arrays with vectors leads to using methods that arrays do not support.

#2 Mixing arrays of different sizes in function parameters.

Wrong approach:

fn process(arr: [i32; 3]) {}
let a = [1, 2, 3, 4];
process(a);

Correct approach:

fn process(arr: &[i32]) {}
let a = [1, 2, 3, 4];
process(&a);

Root cause:

Not realizing array size is part of the type causes type mismatch errors.

#3 Assuming arrays are heap-allocated and can be large without issues.

Wrong approach:

let big_array = [0u8; 1000000]; // large array on stack

Correct approach:

let big_vec = vec![0u8; 1000000]; // heap-allocated vector

Root cause:

Misunderstanding stack vs heap storage leads to stack overflow crashes.

Key Takeaways

Arrays in Rust are fixed-size collections of elements of the same type stored on the stack.

The size of an array is part of its type, enabling compile-time safety checks.

Arrays provide fast, direct access to elements by index starting at zero.

For dynamic or unknown sizes, vectors or slices are better suited than arrays.

Understanding arrays' memory layout and type system integration is key to writing safe and efficient Rust code.

Practice

1. What is true about arrays in Rust?

easy

A. Their size can change after creation.

B. They store multiple values of the same type in a fixed-size list.

C. They can store values of different types together.

D. They do not allow access by index.

Solution

1. Step 1: Understand array type restrictions

   Arrays in Rust hold values all of the same type, ensuring type safety.

2. Step 2: Understand array size behavior

   Arrays have a fixed size that cannot be changed after creation.

3. Final Answer:

   They store multiple values of the same type in a fixed-size list. -> Option B

4. Quick Check:

   Array = fixed size + same type [OK]

Hint: Remember: Rust arrays are fixed size and single type [OK]

Common Mistakes:

• Thinking arrays can hold mixed types
• Assuming arrays can grow or shrink
• Believing arrays don't use indexes

2. Which of the following is the correct way to declare an array of 3 integers in Rust?

easy

A. let arr = [1, 2, 3];

B. let arr = (1, 2, 3);

C. let arr = {1, 2, 3};

D. let arr = <1, 2, 3>;

Solution

1. Step 1: Identify Rust array syntax

   Arrays use square brackets [] with comma-separated values.

2. Step 2: Check other options

   Parentheses () create tuples, curly braces {} are blocks, angle brackets <> are not valid here.

3. Final Answer:

   let arr = [1, 2, 3]; -> Option A

4. Quick Check:

   Array syntax uses [] [OK]

Hint: Arrays use square brackets [] with commas [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Confusing arrays with tuples
• Using invalid symbols like {} or <>

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

let arr = [10, 20, 30, 40];
println!("{}", arr[2]);

medium

A. Index out of bounds error

B. 20

C. 40

D. 30

Solution

1. Step 1: Understand array indexing

   Rust arrays start indexing at 0, so arr[2] is the third element.

2. Step 2: Identify the element at index 2

   The elements are [10, 20, 30, 40], so arr[2] is 30.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Index 2 = 30 [OK]

Hint: Count from zero to find the correct index [OK]

Common Mistakes:

• Starting count at 1 instead of 0
• Confusing element positions
• Expecting runtime error for valid index

4. Find the error in this Rust code snippet:

let arr = [1, 2, 3];
println!("{}", arr[3]);

medium

A. No error, prints 3

B. Type mismatch error

C. Index out of bounds error at runtime

D. Syntax error due to missing semicolon

Solution

1. Step 1: Check array length and index used

   The array has 3 elements with indexes 0, 1, 2. Index 3 is invalid.

2. Step 2: Understand Rust runtime behavior

   Accessing arr[3] causes a runtime panic due to index out of bounds.

3. Final Answer:

   Index out of bounds error at runtime -> Option C

4. Quick Check:

   Invalid index causes runtime panic [OK]

Hint: Check if index is less than array length [OK]

Common Mistakes:

• Assuming index 3 is valid for 3-element array
• Confusing syntax error with runtime error
• Ignoring Rust's panic on invalid index

5. You want to create an array of 5 zeros in Rust. Which code correctly does this?

hard

A. let arr = [0; 5];

B. let arr = [0, 5];

C. let arr = [5; 0];

D. let arr = [0] * 5;

Solution

1. Step 1: Understand Rust array repetition syntax

   The syntax [value; count] creates an array repeating value count times.

2. Step 2: Check each option

   let arr = [0; 5]; uses [0; 5], which creates 5 zeros. Others are invalid or create wrong arrays.

3. Final Answer:

   let arr = [0; 5]; -> Option A

4. Quick Check:

   Use [value; count] to repeat values [OK]

Hint: Use [value; count] to make repeated arrays [OK]

Common Mistakes:

• Using commas instead of semicolon for repetition
• Confusing multiplication syntax with arrays
• Reversing value and count in repetition