Loop

The loop keyword in Rust is a control flow construct that creates an unconditional, infinite loop. It continuously executes the associated block of code until an explicit termination instruction is encountered. Because it lacks a conditional evaluation phase, the compiler treats loop as guaranteeing execution, which directly impacts control flow analysis, type inference, and definite initialization checks.

Syntax and Control Flow

The execution flow within a loop is manipulated using two primary keywords:

• break: Immediately halts execution of the loop and transfers control to the statement following the loop block.
• continue: Bypasses any remaining statements in the current iteration and immediately jumps back to the beginning of the loop block.

let mut counter = 0;

loop {
    counter += 1;
    
    if counter == 1 {
        continue; // Skips the rest of this iteration
    }
    
    if counter == 2 {
        break; // Terminates the loop entirely
    }
}

Expression Semantics and Yielding Values

In Rust, loop is an expression rather than a statement. This means a loop can evaluate to a value and bind that value to a variable. Values are yielded out of the loop by appending the desired expression directly after the break keyword.

let _value: i32 = loop {
    // Yields 42, terminates the loop, and binds to '_value'
    break 42; 
};

If a loop does not explicitly yield a value via break, its evaluation type is the unit type (), provided it eventually breaks. If the loop never breaks, its type evaluates to the never type (!).

Loop Labels

When dealing with nested loops, break and continue apply to the innermost loop by default. Rust utilizes loop labels—identifiers prefixed with a single quote (')—to explicitly target specific outer loops. A label is declared immediately before the loop keyword, followed by a colon.

'outer_label: loop {
    loop {
        // Terminates the outer loop, bypassing the inner loop's default behavior
        break 'outer_label; 
    }
}

Labels can be combined with value yielding in a single break statement. The label must precede the yielded value.

let _result = 'outer: loop {
    loop {
        // Breaks the loop labeled 'outer' and yields the value 100
        break 'outer 100;
    }
};

Master Rust with Deep Grasping Methodology!

Learn More