> ## 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 While Loop
A `while` loop is a conditional control flow construct that repeatedly executes a block of code as long as a specified boolean expression evaluates to `true`. The condition is evaluated before each iteration, meaning the loop body may execute zero or more times depending on the initial state of the condition.
```text theme={"dark"}
while boolean_expression {
// statements executed as long as boolean_expression is true
}
```
Unlike languages such as C, C++, or Java, Rust does not require parentheses around the `while` loop condition. The Rust compiler actively discourages unnecessary parentheses via the `unused_parens` lint, enforcing a cleaner, idiomatic syntax.
## Technical Characteristics
* **Strict Boolean Typing:** The condition must explicitly evaluate to the `bool` type. Rust does not support implicit type coercion; integers, pointers, or standard objects cannot be evaluated as "truthy" or "falsy".
* **Expression Type:** A `while` loop is an expression that always evaluates to the unit type `()`.
* **No Value Return on Break:** Unlike Rust's unconditional `loop` construct, you cannot return a value from a `while` loop using the `break` keyword.
## Control Flow Modifiers
Execution within the loop body can be altered using standard control flow keywords:
* `continue`: Immediately halts the current iteration and jumps back to the condition evaluation at the top of the loop.
* `break`: Immediately terminates the loop entirely, transferring execution to the first statement following the loop block.
```rust theme={"dark"}
let mut counter = 0;
while counter < 10 {
counter += 1;
if counter % 2 == 0 {
continue; // Skips to the next condition evaluation
}
if counter >= 7 {
break; // Exits the while loop completely
}
}
```
## Loop Labels
When dealing with nested `while` loops, Rust allows you to annotate loops with labels (prefixed by a single quote `'`). This enables `break` and `continue` statements to target specific outer loops rather than the innermost loop they reside in.
```rust theme={"dark"}
let mut x = 0;
'outer: while x < 5 {
x += 1;
let mut y = 0;
while y < 5 {
y += 1;
if x * y == 6 {
break 'outer; // Terminates the loop labeled 'outer
}
if y == 3 {
continue 'outer; // Skips to the next iteration of 'outer
}
}
}
```
## The `while let` Variant
Rust provides a specialized syntactic sugar called `while let` that combines a `while` loop with pattern matching. It repeatedly executes the loop body as long as a value successfully matches a specified pattern, automatically destructuring the value in the process.
```rust theme={"dark"}
let mut vector = vec![1, 2, 3];
// The loop continues as long as `pop()` returns `Some(value)`
// It terminates automatically when `pop()` returns `None`
while let Some(element) = vector.pop() {
// `element` is bound and available in this scope
let _squared = element * element;
}
```
Tired of Poor Rust Skills? Fix That With Deep Grasping!
Learn More
