Skip to main content

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.

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

'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.
'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. 
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.
Master Rust with Deep Grasping Methodology!Learn More