Loop construct in Rust - Deep Dive

Overview - Loop construct

What is it?

A loop construct in Rust is a way to repeat a set of instructions multiple times. It helps run the same code again and again until a condition is met or forever if no condition stops it. Rust has different kinds of loops like 'loop', 'while', and 'for' to handle various repeating tasks. These loops make programs efficient by avoiding repeated code writing.

Why it matters

Loops exist to automate repetitive tasks, saving time and reducing errors. Without loops, programmers would have to write the same code many times, making programs long and hard to maintain. Loops let computers do heavy work quickly, like processing lists or waiting for user input. They are essential for almost every program that needs to handle repeated actions.

Where it fits

Before learning loops, you should understand basic Rust syntax, variables, and expressions. After mastering loops, you can learn about functions, iterators, and more advanced control flow like pattern matching and async programming. Loops are a foundation for handling collections and building efficient algorithms.

Mental Model

Core Idea

A loop runs the same block of code repeatedly until a stopping condition is met or forever if none is given.

Think of it like...

A loop is like a washing machine cycle that keeps spinning clothes until the timer runs out or you press stop.

┌───────────────┐
│   Start Loop  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Execute Block │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Check Condition│
└──────┬────────┘
       │Yes (stop)
       ▼
     End Loop
       │
       └─No─────▶ Back to Execute Block

Build-Up - 7 Steps

1

Foundation

Basic infinite loop with loop keyword

Concept: Introduce the simplest loop that runs forever unless stopped.

In Rust, the 'loop' keyword creates an infinite loop. It repeats the code inside endlessly until you break out. Example: fn main() { loop { println!("Hello, world!"); break; // stops the loop immediately } } This prints "Hello, world!" once because of the break.

Result

The program prints "Hello, world!" once and then stops.

Understanding the 'loop' keyword shows how Rust can repeat code indefinitely and how to control it with 'break'.

2

Foundation

Conditional repetition with while loop

Concept: Learn how to repeat code while a condition is true.

The 'while' loop runs as long as a condition stays true. Example: fn main() { let mut count = 0; while count < 3 { println!("Count is {}", count); count += 1; } } This prints count values from 0 to 2.

Result

Output: Count is 0 Count is 1 Count is 2

Using 'while' loops lets you repeat code based on changing conditions, making loops more flexible.

3

Intermediate

Iterating with for loop over ranges

🤔Before reading on: do you think 'for' loops can only work with numbers, or can they work with other collections too? Commit to your answer.

Concept: Use 'for' loops to repeat code over a sequence of values like numbers or items in a list.

The 'for' loop runs once for each item in a collection or range. Example: fn main() { for i in 1..4 { // 1 to 3 println!("Number {}", i); } } This prints numbers 1, 2, and 3.

Result

Output: Number 1 Number 2 Number 3

Knowing 'for' loops work with ranges and collections unlocks powerful ways to process data step-by-step.

4

Intermediate

Using break and continue in loops

🤔Before reading on: do you think 'continue' stops the whole loop or just skips one step? Commit to your answer.

Concept: Control loop flow by stopping early or skipping certain steps.

Inside loops, 'break' stops the loop completely, while 'continue' skips the rest of the current step and moves to the next. Example: fn main() { for i in 1..6 { if i == 3 { continue; // skip printing 3 } if i == 5 { break; // stop loop at 5 } println!("Number {}", i); } } This prints 1, 2, 4 and stops before 5.

Result

Output: Number 1 Number 2 Number 4

Mastering 'break' and 'continue' lets you fine-tune loops to handle complex conditions and improve efficiency.

5

Intermediate

Loop labels for nested loops control

🤔Before reading on: do you think 'break' inside nested loops stops only the inner loop or all loops? Commit to your answer.

Concept: Use labels to specify which loop to break or continue when loops are nested.

When loops are inside other loops, 'break' and 'continue' affect only the innermost loop by default. Labels let you control outer loops. Example: fn main() { 'outer: for i in 1..4 { for j in 1..4 { if i * j == 4 { break 'outer; // stops the outer loop } println!("i={}, j={}", i, j); } } } This stops all loops when i*j equals 4.

Result

Output: i=1, j=1 i=1, j=2 i=1, j=3 i=2, j=1

Labels give precise control in complex nested loops, preventing bugs and unexpected behavior.

6

Advanced

Returning values from loops

🤔Before reading on: do you think loops can produce a value when they end, or are they only for repeating actions? Commit to your answer.

Concept: Loops in Rust can return a value when stopped with 'break', allowing them to produce results.

In Rust, you can use 'break' with a value to return from a loop. Example: fn main() { let mut count = 0; let result = loop { count += 1; if count == 5 { break count * 2; // returns 10 } }; println!("Result is {}", result); } This prints the value returned by the loop.

Result

Output: Result is 10

Knowing loops can return values lets you write concise code that combines repetition and result calculation.

7

Expert

How Rust loops optimize safety and performance

🤔Before reading on: do you think Rust loops add runtime checks that slow down code, or are they optimized away? Commit to your answer.

Concept: Rust loops are designed to be safe without sacrificing speed, using compile-time checks and zero-cost abstractions.

Rust's loops use compile-time checks to prevent errors like infinite loops or invalid memory access. The compiler optimizes loops to machine code without extra overhead. For example, 'for' loops over ranges compile to efficient machine instructions. Rust also enforces variable mutability and borrowing rules inside loops to avoid bugs. This balance of safety and speed is a key Rust feature.

Result

Loops run fast and safe, with no hidden runtime cost.

Understanding Rust's loop design reveals how safety and performance can coexist, guiding better code writing.

Under the Hood

Rust loops compile down to low-level machine instructions that jump back to the start of the loop block until a condition or break stops them. The compiler checks loop conditions and variable usage at compile time to prevent errors. For 'for' loops, Rust uses the Iterator trait to get each item efficiently. The 'loop' keyword creates an unconditional jump, while 'while' and 'for' add conditional jumps based on boolean checks.

Why designed this way?

Rust was designed to provide memory safety and concurrency without slowing down programs. Loops needed to be both safe and fast. Using compile-time checks avoids runtime errors and overhead. The Iterator trait for 'for' loops allows flexible looping over many data types, making loops powerful and generic. This design avoids common bugs like infinite loops or data races.

┌───────────────┐
│   Start Loop  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Execute Code │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Check Condition│
└──────┬────────┘
       │Yes (stop)
       ▼
     End Loop
       │
       └─No─────▶ Back to Execute Code

For 'for' loops:

┌───────────────┐
│ Get Next Item │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Execute Code │
└──────┬────────┘
       │
       ▼
  Repeat until no items

Myth Busters - 4 Common Misconceptions

Quick: Does 'break' inside a nested loop stop all loops or just the current one? Commit to your answer.

Common Belief: Break stops all loops immediately, no matter how deep they are nested.

Reality: Break only stops the innermost loop unless you use a label to specify an outer loop.

Why it matters: Without labels, you might think your program stops all loops but it only stops one, causing unexpected infinite loops or wrong behavior.

Quick: Can 'for' loops only iterate over numbers? Commit to your answer.

Common Belief: For loops only work with numbers or ranges.

Reality: For loops work with any type that implements the Iterator trait, including collections like arrays, vectors, and custom types.

Why it matters: Limiting 'for' loops to numbers restricts their power and leads to inefficient code when working with collections.

Quick: Does 'continue' stop the entire loop or just skip one iteration? Commit to your answer.

Common Belief: Continue stops the whole loop immediately.

Reality: Continue skips only the rest of the current iteration and moves to the next one.

Why it matters: Misusing 'continue' can cause logic errors, skipping important code or causing infinite loops.

Quick: Do loops in Rust always add runtime overhead compared to other languages? Commit to your answer.

Common Belief: Rust loops are slower because of safety checks at runtime.

Reality: Rust loops have zero-cost abstractions; safety checks happen at compile time, so loops run as fast as in low-level languages.

Why it matters: Believing Rust loops are slow may discourage using them properly or lead to premature optimization.

Expert Zone

1

Rust's 'for' loops rely on the Iterator trait, allowing custom types to define how they are looped over, enabling powerful abstractions.

2

Loop labels are rarely needed but essential in complex nested loops to avoid subtle bugs and improve code clarity.

3

Using 'break' with a value to return from loops is a unique Rust feature that can simplify code by combining looping and result calculation.

When NOT to use

Loops are not ideal when working with asynchronous code; instead, use async streams or combinators. For complex data processing, iterator chains or functional methods like map and filter are often clearer and safer than manual loops.

Production Patterns

In real-world Rust code, loops are often combined with iterators for efficient data processing. Nested loops use labels sparingly to maintain readability. Returning values from loops is common in parsing or searching algorithms. Infinite loops with 'loop' are used in event-driven or embedded systems where the program runs continuously.

Connections

Recursion

Alternative approach to repetition

Understanding loops helps grasp recursion since both repeat actions; loops do it with iteration, recursion with function calls, showing different ways to solve repeated tasks.

Finite State Machines (FSM)

Loops implement repeated state transitions

Loops in programming often model FSMs by repeatedly checking conditions and changing states, linking control flow to system design.

Manufacturing assembly lines

Sequential repeated processes

Loops are like assembly lines repeating steps on products; this connection shows how programming automates repetitive real-world tasks efficiently.

Common Pitfalls

#1 Creating an infinite loop unintentionally

Wrong approach:

fn main() {
let mut i = 0;
while i < 5 {
println!("{}", i);
// forgot to increase i
}
}

Correct approach:

fn main() {
let mut i = 0;
while i < 5 {
println!("{}", i);
i += 1;
}
}

Root cause:

Forgetting to update the loop variable causes the condition to never become false, making the loop run forever.

#2 Misusing 'continue' to skip important code

Wrong approach:

for i in 0..5 {
if i == 2 {
continue;
}
println!("Number {}", i);
println!("This always runs");
}

Correct approach:

for i in 0..5 {
if i == 2 {
println!("Skipping 2");
continue;
}
println!("Number {}", i);
println!("This always runs");
}

Root cause:

Not realizing 'continue' skips the rest of the loop body, so code after it won't run for that iteration.

#3 Breaking only inner loop when intending to stop outer loop

Wrong approach:

for i in 1..5 {
for j in 1..5 {
if i * j == 6 {
break; // breaks inner loop only
}
println!("i={}, j={}", i, j);
}
}

Correct approach:

'outer: for i in 1..5 {
for j in 1..5 {
if i * j == 6 {
break 'outer; // breaks outer loop
}
println!("i={}, j={}", i, j);
}
}

Root cause:

Not using loop labels causes 'break' to affect only the innermost loop, leading to unexpected continuation.

Key Takeaways

Loops let you repeat code efficiently, saving time and reducing errors in programs.

Rust provides three main loops: 'loop' for infinite repetition, 'while' for conditional repetition, and 'for' for iterating over collections.

Control statements like 'break' and 'continue' let you manage loop flow precisely, including in nested loops with labels.

Rust loops are safe and fast because the compiler checks conditions and optimizes code without runtime cost.

Advanced features like returning values from loops and using iterators make Rust loops powerful tools for real-world programming.

Practice

1. What does the loop keyword do in Rust?

easy

A. It runs the loop a fixed number of times.

B. It creates an infinite loop that runs until break is called.

C. It runs the loop only once.

D. It creates a loop that runs only if a condition is true.

Solution

1. Step 1: Understand the loop keyword

   The loop keyword in Rust creates a loop that repeats forever unless stopped.

2. Step 2: Identify how to stop the loop

   To stop a loop, you must use break inside it; otherwise, it runs infinitely.

3. Final Answer:

   It creates an infinite loop that runs until break is called. -> Option B

4. Quick Check:

   loop = infinite loop until break [OK]

Hint: Remember: loop runs forever unless broken [OK]

Common Mistakes:

• Thinking loop runs a fixed number of times
• Confusing loop with for or while
• Assuming loop stops automatically

2. Which of the following is the correct syntax to create an infinite loop in Rust?

easy

A. loop { println!("Hello"); }

B. while True { println!("Hello"); }

C. for i in 0.. { println!("Hello"); }

D. repeat { println!("Hello"); }

Solution

1. Step 1: Check Rust syntax for infinite loops

   Rust uses the keyword loop to create an infinite loop.

2. Step 2: Verify each option

   while True { println!("Hello"); } uses while True which is invalid syntax in Rust. for i in 0.. { println!("Hello"); } uses for with an infinite range, but 0.. is not valid without an end. repeat { println!("Hello"); } uses repeat which does not exist in Rust. loop { println!("Hello"); } correctly uses loop.

3. Final Answer:

   loop { println!("Hello"); } -> Option A

4. Quick Check:

   Correct infinite loop syntax = loop [OK]

Hint: Use loop keyword for infinite loops in Rust [OK]

Common Mistakes:

• Using while True which is invalid in Rust
• Trying to use repeat which doesn't exist
• Using for without a proper range

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

let mut count = 0;
loop {
    count += 1;
    if count == 3 {
        break;
    }
    println!("{}", count);
}

medium

A. 1 2

B. 0 1 2

C. 1 2 3

D. No output (infinite loop)

Solution

1. Step 1: Trace the loop iterations

   Initially, count = 0. In the first loop, count becomes 1, which is printed. Then count becomes 2 and printed. When count becomes 3, the loop breaks before printing.

2. Step 2: List printed values

   Only 1 and 2 are printed before the break stops the loop.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Loop prints until count == 3, so prints 1 and 2 [OK]

Hint: Check when break happens before printing [OK]

Common Mistakes:

• Printing count after break condition
• Starting count from 0 but expecting 0 to print
• Assuming infinite loop without break

4. Identify the error in this Rust loop code:

let mut i = 0;
loop {
    if i == 5 {
        break;
    }
    println!("{}", i);
}

medium

A. 'println!' macro syntax is wrong.

B. Missing semicolon after 'break'.

C. 'loop' keyword is used incorrectly.

D. Variable 'i' is not incremented, causing an infinite loop.

Solution

1. Step 1: Check loop control variable

   The variable i is initialized but never changed inside the loop.

2. Step 2: Understand loop behavior

   Since i never increments, i == 5 is never true, so break is never reached, causing an infinite loop.

3. Final Answer:

   Variable 'i' is not incremented, causing an infinite loop. -> Option D

4. Quick Check:

   Loop needs variable increment to reach break [OK]

Hint: Always update loop variables to avoid infinite loops [OK]

Common Mistakes:

• Forgetting to increment loop variable
• Assuming break works without condition change
• Misunderstanding loop syntax

5. How can you use a loop to sum numbers from 1 to 5 in Rust?

hard

A. Use loop with a counter but never update sum.

B. Use loop without break and add numbers forever.

C. Use a loop with a counter and break when counter > 5, adding each to sum.

D. Use loop with a counter but break immediately without adding.

Solution

1. Step 1: Plan the loop with counter and sum

   Initialize a counter at 1 and sum at 0. Use loop to add counter to sum.

2. Step 2: Use break to stop after 5

   Increment counter each loop. When counter > 5, use break to exit loop.

3. Step 3: Result is sum of 1 to 5

   This method correctly sums numbers 1+2+3+4+5 = 15.

4. Final Answer:

   Use a loop with a counter and break when counter > 5, adding each to sum. -> Option C

5. Quick Check:

   Loop + counter + break = sum 1 to 5 [OK]

Hint: Increment counter and break after limit to sum [OK]

Common Mistakes:

• Not breaking loop causing infinite sum
• Not incrementing counter
• Not adding counter to sum