> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Rust Labeled Loop
A labeled loop in Rust is a control flow mechanism that assigns a unique identifier (a label) to a loop construct, allowing `break` and `continue` statements to explicitly target a specific loop within nested loop hierarchies. By default, `break` and `continue` operate on the innermost enclosing loop; labels override this lexical scoping behavior to transfer control to a higher-level loop.
Labels are defined using a single quote (`'`) followed by a valid Rust identifier and a colon (`:`). They are placed immediately preceding the loop keyword.
## Syntax
```rust theme={"dark"}
'label_name: loop {
// Control flow targeting the label
if true {
continue 'label_name;
}
break 'label_name;
}
```
Labels can be applied to all Rust loop constructs: `loop`, `while`, `while let`, and `for`.
## Control Flow Mechanics
When a label is invoked by a control flow statement, the compiler bypasses the innermost loop context and resolves the instruction against the AST node of the labeled loop:
* **`break 'label;`**: Immediately terminates the execution of the loop associated with `'label`. Control flow resumes at the first statement following the labeled loop's closing brace.
* **`continue 'label;`**: Immediately halts the current iteration of the innermost loop and transfers control to the next iteration of the loop associated with `'label`. For `for` loops, this advances the iterator; for `while` loops, this re-evaluates the condition.
```rust theme={"dark"}
'outer: for i in 1..=3 {
'inner: for j in 1..=3 {
if i == 1 && j == 2 {
continue 'outer; // Skips the rest of 'inner, advances 'outer to i = 2
}
if i == 2 && j == 3 {
break 'outer; // Terminates 'outer completely
}
}
}
```
## Returning Values with Labels
In Rust, the unconditional `loop` construct is an expression that can return a value via the `break` statement. When using labeled loops, the return expression is placed immediately after the label identifier.
*Note: Value return via `break` is strictly limited to `loop` constructs; `for` and `while` loops evaluate to the unit type `()` and cannot return values.*
```rust theme={"dark"}
let computed_value = 'evaluation: loop {
let mut internal_state = 0;
loop {
internal_state += 1;
if internal_state > 10 {
// Terminates 'evaluation and binds 42 to computed_value
break 'evaluation 42;
}
}
};
```
## Scope and Shadowing
Loop labels and lifetimes share the same namespace in Rust, which is distinct from the namespaces used for variables and types. They follow lexical scoping rules. If an inner loop defines a label with the exact same identifier as an outer loop, the inner label shadows the outer one. Any `break` or `continue` referencing that identifier within the inner loop's scope will resolve to the inner loop. The Rust compiler will emit a warning for label shadowing to prevent unintended control flow resolution.
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
