Loop with break in Rust - Step-by-Step Execution

Concept Flow - Loop with break

Start Loop

↓

Execute Loop Body

↓

Check break condition

↓

Exit Loop

The loop runs repeatedly until the break condition is true, then it stops immediately.

Execution Sample

Rust

let mut count = 0;
loop {
    if count == 3 {
        break;
    }
    count += 1;
}

This code counts from 0 up, stopping the loop when count reaches 3.

Execution Table

Step	count	Condition (count == 3)	Action	Loop Status
1	0	false	count += 1 -> 1	continue
2	1	false	count += 1 -> 2	continue
3	2	false	count += 1 -> 3	continue
4	3	true	break	exit

💡 At step 4, count == 3 is true, so break stops the loop.

Variable Tracker

Variable	Start	After 1	After 2	After 3	Final
count	0	1	2	3	3

Key Moments - 2 Insights

Why does the loop stop exactly when count is 3?

Because at step 4 in the execution_table, the condition count == 3 is true, triggering the break which immediately exits the loop.

What happens if the break condition never becomes true?

The loop would run forever because break is never called, so the loop never exits (infinite loop).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of count at step 3?

A 1

B 2

C 3

D 0

💡 Hint

Check the 'count' column in the execution_table row for step 3.

At which step does the loop stop running?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'Loop Status' column in the execution_table to find when it says 'exit'.

If the break condition was changed to count == 5, what would happen at step 4?

A Loop breaks at step 4

B count resets to 0

C Loop continues because condition is false

D Error occurs

💡 Hint

Refer to the 'Condition' column logic in the execution_table and imagine count == 3 vs count == 5.

Concept Snapshot

Rust loop with break:
loop {
  if condition {
    break;
  }
  // code
}
The loop runs until break stops it immediately when condition is true.

Full Transcript

This example shows a Rust loop that counts up from zero. Each time the loop runs, it checks if count equals 3. If yes, it breaks out of the loop. Otherwise, it adds 1 to count and repeats. The execution table tracks count and the condition each step. When count reaches 3 at step 4, the break stops the loop. Variables change as count goes from 0 to 3. Beginners often wonder why the loop stops exactly at 3 and what happens if break never triggers. The quiz asks about count values and when the loop exits, reinforcing understanding of break behavior.

Practice

1. What does the break keyword do inside a loop in Rust?

easy

A. It restarts the loop from the beginning.

B. It stops the loop immediately and exits it.

C. It skips the current iteration and continues the loop.

D. It pauses the loop until a condition is true.

Solution

1. Step 1: Understand the role of break in loops

   The break keyword is used to stop the loop immediately, no matter where it is in the loop.

2. Step 2: Compare with other loop controls

   Unlike continue which skips to the next iteration, break exits the loop completely.

3. Final Answer:

   It stops the loop immediately and exits it. -> Option B

4. Quick Check:

   break = stop loop [OK]

Hint: Remember: break means stop the loop now [OK]

Common Mistakes:

• Confusing break with continue
• Thinking break pauses instead of stops
• Assuming break restarts the loop

2. Which of the following is the correct syntax to break out of a loop in Rust?

easy

A. break()

B. exit loop;

C. break;

D. stop;

Solution

1. Step 1: Recall Rust loop break syntax

   In Rust, to exit a loop, you simply write break; with a semicolon.

2. Step 2: Check other options for syntax errors

   break() is invalid because break is a keyword, not a function. exit loop; and stop; are not Rust keywords.

3. Final Answer:

   break; -> Option C

4. Quick Check:

   Correct break syntax = break; [OK]

Hint: Use break with semicolon to exit loops [OK]

Common Mistakes:

• Using break as a function call
• Writing break without semicolon
• Using non-existent keywords like exit or stop

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. 1 2 3

C. 3

D. 0 1 2

Solution

1. Step 1: Trace the loop iterations and print statements

   Loop starts with count = 0. Each loop adds 1 to count. When count reaches 3, break stops the loop. The print happens only if count is not 3.

2. Step 2: List printed values

   When count=1, prints 1; count=2, prints 2; count=3 triggers break before print, so 3 is not printed.

3. Final Answer:

   1 2 -> Option A

4. Quick Check:

   Print before break stops at 3, so output is 1 2 [OK]

Hint: Break stops before printing 3, so only 1 and 2 print [OK]

Common Mistakes:

• Assuming break prints the last value
• Counting from 0 instead of 1
• Ignoring that break stops loop before print

4. Identify the error in this Rust code snippet:

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

medium

A. Missing semicolon after break

B. Variable i is not mutable

C. println! macro is used incorrectly

D. Loop condition is missing

Solution

1. Step 1: Check syntax around break statement

   In Rust, statements must end with a semicolon. The break statement here lacks a semicolon.

2. Step 2: Verify other parts of the code

   Variable i is mutable, println! is correctly used, and loop without condition is valid in Rust.

3. Final Answer:

   Missing semicolon after break -> Option A

4. Quick Check:

   break needs semicolon to avoid syntax error [OK]

Hint: Always put semicolon after break [OK]

Common Mistakes:

• Forgetting semicolon after break
• Thinking loop needs condition
• Misreading println! syntax

5. You want to sum numbers from 1 to 10 but stop adding when the sum reaches or exceeds 20. Which Rust code correctly uses a loop with break to do this?

hard

A. let mut sum = 0;
let mut n = 1;
loop {
sum += n;
if sum >= 20 {
break;
}
n += 1;
}
println!("{}", sum);

B. let mut sum = 0;
for n in 1..=10 {
sum += n;
if sum >= 20 {
break;
}
}
println!("{}", sum);

C. let mut sum = 0;
let mut n = 1;
while n <= 10 {
sum += n;
if sum >= 20 {
break;
}
n += 1;
}
println!("{}", sum);

D. let mut sum = 0;
let mut n = 1;
loop {
if n > 10 {
break;
}
sum += n;
if sum >= 20 {
break;
}
n += 1;
}
println!("{}", sum);

Solution

1. Step 1: Understand the problem requirements

   Sum numbers from 1 to 10, but stop if sum reaches or exceeds 20. Use loop with break.

2. Step 2: Analyze each option for correctness

   let mut sum = 0; let mut n = 1; loop { sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); breaks after adding sum >= 20 but does not stop when n > 10, so it does not enforce the limit to 10. let mut sum = 0; for n in 1..=10 { sum += n; if sum >= 20 { break; } } println!("{}", sum); uses for loop, not loop. let mut sum = 0; let mut n = 1; while n <= 10 { sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); uses while loop, not loop. let mut sum = 0; let mut n = 1; loop { if n > 10 { break; } sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); correctly breaks if n > 10 or sum >= 20, stopping properly.

3. Final Answer:

   Correctly uses loop with break to stop at sum >= 20 or n > 10. -> Option D

4. Quick Check:

   let mut sum = 0; let mut n = 1; loop { if n > 10 { break; } sum += n; if sum >= 20 { break; } n += 1; } println!("{}", sum); [OK]

Hint: Check all break conditions to avoid infinite loops [OK]

Common Mistakes:

• Missing break for loop exit condition
• Using wrong loop type
• Not checking both sum and count limits