Loop labels in Rust - Mini Project: Build & Apply

Loop Labels in Rust

📖 Scenario: Imagine you are organizing a treasure hunt game. You have several boxes, and each box contains several smaller boxes. You want to find a special item inside these nested boxes. To do this, you need to check each smaller box inside each big box. Sometimes, when you find the item, you want to stop searching immediately, even if you are inside a nested loop.

🎯 Goal: You will write a Rust program that uses loop labels to break out of nested loops when a special item is found.

📋 What You'll Learn

Create a nested loop structure with two loops: an outer loop labeled 'outer and an inner loop labeled 'inner.

Use break 'outer to exit both loops when a condition is met.

Print messages to show the progress of the search and when the item is found.

💡 Why This Matters

🌍 Real World

Loop labels help when you have nested tasks and want to stop or skip outer tasks from inside inner tasks, like searching in nested boxes or menus.

💼 Career

Understanding loop labels is useful for writing clear and efficient Rust code, especially in systems programming, game development, and complex data processing.

1

Create nested loops with labels

Write a nested loop structure in Rust with an outer loop labeled 'outer and an inner loop labeled 'inner. Inside the inner loop, print "Checking smaller box". Inside the outer loop, print "Checking big box" before the inner loop starts.

Rust

# Create an outer loop labeled 'outer'
# Inside it, print "Checking big box"
# Create an inner loop labeled 'inner'
# Inside it, print "Checking smaller box"

Hint

Use 'outer: loop { ... } to label the outer loop and 'inner: loop { ... } for the inner loop. Use println! to print messages.

2

Add a counter to track smaller boxes

Create a variable called smaller_box_count and set it to 0 before the outer loop. Inside the inner loop, increase smaller_box_count by 1 each time you check a smaller box.

Rust

'outer: loop {
    println!("Checking big box");
    'inner: loop {
        println!("Checking smaller box");
        // Increase smaller_box_count here
        break 'inner;
    }
    break 'outer;
}

Hint

Declare smaller_box_count as mutable with let mut. Increase it inside the inner loop.

3

Use loop labels to break out when item is found

Inside the inner loop, add an if statement that checks if smaller_box_count equals 3. If true, print "Item found!" and use break 'outer to stop both loops.

Rust

let mut smaller_box_count = 0;
'outer: loop {
    println!("Checking big box");
    'inner: loop {
        println!("Checking smaller box");
        smaller_box_count += 1;
        // If smaller_box_count is 3, print "Item found!" and break 'outer
        break 'inner;
    }
    break 'outer;
}

Hint

Use if smaller_box_count == 3 to check the count. Use break 'outer to exit both loops.

4

Print the total smaller boxes checked

After the loops, print "Total smaller boxes checked: {smaller_box_count}" using an f-string style with println!.

Rust

let mut smaller_box_count = 0;
'outer: loop {
    println!("Checking big box");
    'inner: loop {
        println!("Checking smaller box");
        smaller_box_count += 1;
        if smaller_box_count == 3 {
            println!("Item found!");
            break 'outer;
        }
        break 'inner;
    }
}
// Print total smaller boxes checked here

Hint

Use println!("Total smaller boxes checked: {}", smaller_box_count); to show the final count.

Practice

1. What is the main purpose of using loop labels in Rust?

easy

A. To create infinite loops without conditions.

B. To declare variables inside loops.

C. To name loops so you can break or continue specific loops inside nested loops.

D. To automatically parallelize loops for performance.

Solution

1. Step 1: Understand loop labels concept

   Loop labels let you assign a name to a loop, especially useful when loops are nested.

2. Step 2: Identify the use of labels

   Labels allow you to break or continue a specific loop by referring to its name, avoiding ambiguity.

3. Final Answer:

   To name loops so you can break or continue specific loops inside nested loops. -> Option C

4. Quick Check:

   Loop labels = control nested loops [OK]

Hint: Labels name loops for clear break/continue control [OK]

Common Mistakes:

• Thinking labels create infinite loops
• Confusing labels with variable declarations
• Assuming labels optimize performance automatically

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

easy

A. label: loop { /* code */ }

B. loop label { /* code */ }

C. loop: label { /* code */ }

D. loop { label: /* code */ }

Solution

1. Step 1: Recall Rust loop label syntax

   In Rust, a loop label is written as 'label: before the loop keyword.

2. Step 2: Match syntax options

   label: loop { /* code */ } correctly places the label before the loop with a colon, e.g., 'label: loop {}.

3. Final Answer:

   label: loop { /* code */ } -> Option A

4. Quick Check:

   Label syntax = 'label: loop' [OK]

Hint: Labels come before loop with a colon [OK]

Common Mistakes:

• Placing label after loop keyword
• Using colon after loop instead of label
• Putting label inside loop body

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

fn main() {
    let mut count = 0;
    'outer: loop {
        println!("Outer loop: {}", count);
        let mut inner_count = 10;
        loop {
            println!("  Inner loop: {}", inner_count);
            if inner_count == 9 {
                break 'outer;
            }
            inner_count -= 1;
        }
        count += 1;
    }
    println!("Done");
}

medium

A. Outer loop: 0
Inner loop: 10
Inner loop: 9
Inner loop: 8
Done

B. Outer loop: 0
Inner loop: 10
Done

C. Infinite loop with no output

D. Outer loop: 0
Inner loop: 10
Inner loop: 9
Done

Solution

1. Step 1: Trace outer loop first iteration

   count starts at 0, prints "Outer loop: 0". Then inner loop starts with inner_count = 10.

2. Step 2: Trace inner loop and break condition

   Inner loop prints 10, then 9. When inner_count == 9, it breaks the 'outer loop, exiting both loops.

3. Final Answer:

   Outer loop: 0 Inner loop: 10 Inner loop: 9 Done -> Option D

4. Quick Check:

   Break 'outer stops both loops at inner_count 9 [OK]

Hint: Break 'label exits named loop immediately [OK]

Common Mistakes:

• Thinking break only exits inner loop
• Missing that break 'outer exits both loops
• Assuming loops continue infinitely

4. Identify the error in this Rust code using loop labels:

fn main() {
    'start: loop {
        loop {
            break start;
        }
    }
}

medium

A. Missing apostrophe before label name in break statement.

B. Label 'start' is not defined before use.

C. Cannot break a labeled loop from an inner loop.

D. Syntax error: break statements cannot have labels.

Solution

1. Step 1: Check break statement syntax

   In Rust, breaking a labeled loop requires the label with an apostrophe, e.g., break 'start;.

2. Step 2: Identify the missing apostrophe

   The code uses break start; missing the apostrophe before the label name, causing a syntax error.

3. Final Answer:

   Missing apostrophe before label name in break statement. -> Option A

4. Quick Check:

   Label break syntax = break 'label [OK]

Hint: Always prefix label with apostrophe in break/continue [OK]

Common Mistakes:

• Omitting apostrophe in break label
• Assuming labels are variables
• Thinking break can't target outer loops

5. Given nested loops labeled 'outer and 'inner, how can you skip the current iteration of the outer loop from inside the inner loop?

hard

A. Use break 'inner; inside the inner loop.

B. Use continue 'outer; inside the inner loop.

C. Use continue; without label inside the inner loop.

D. Use break 'outer; inside the inner loop.

Solution

1. Step 1: Understand continue with labels

   Using continue 'outer; skips the current iteration of the loop labeled 'outer, jumping to its next iteration.

2. Step 2: Differentiate break and continue

   break exits the loop, while continue skips to the next iteration. To skip outer loop iteration from inner loop, use continue 'outer;.

3. Final Answer:

   Use continue 'outer; inside the inner loop. -> Option B

4. Quick Check:

   continue 'label skips that loop iteration [OK]

Hint: Use continue 'label to skip outer loop iteration [OK]

Common Mistakes:

• Using break instead of continue to skip iteration
• Omitting label in continue statement
• Confusing break and continue effects