Rust 26 🦀 Concise Control Flow with if let and while let
A match expression is exhaustive. It forces you to handle every variant, which is exactly what you want when the type has a fixed set of possibilities and every one matters. But sometimes you care about one variant and want to ignore the rest. Writing a full match with a catch-all _ => {} arm is verbose for what is a simple check. Rust provides two constructs for this: if let and while let. They combine pattern matching with conditional execution, letting you handle one pattern and skip the rest without the ceremony of a full match.
This chapter covers if let and while let in full. You will learn the syntax, how they differ from match and while, how they interact with else and else if let, and the patterns where they replace verbose matches. You will also see the limitations—the exhaustiveness check does not apply—and the situations where a full match is still the better choice.
Key point: if let runs a block when a value matches a pattern. while let loops while a value matches a pattern. Both are shorthand for a match with one meaningful arm and a catch-all that does nothing. They do not check exhaustiveness, so they are appropriate when the unmatched cases are genuinely irrelevant.
Why if let and while let exist
The verbose match problem. A common pattern is to match on an Option<T> and do something only when it is Some. A full match requires an arm for None, even if the arm does nothing.
match config_value {
Some(value) => println!("Value: {}", value),
None => {}
}The None arm is noise. It exists to satisfy the exhaustiveness check. if let expresses the same intent without the noise.
if let Some(value) = config_value {
println!("Value: {}", value);
}The reader sees immediately that only the Some case is handled. The None case is silently ignored, which is the intent.
The nested match problem. When the pattern is complex—an enum variant with several fields, or an Option inside a Result—the match arms become deeply nested. if let flattens the structure by removing the outer match and keeping only the arm that matters.
if let Ok(Some(user)) = find_user(id) {
println!("Found: {}", user.name);
}The single pattern matches Ok(Some(user)) and extracts the user. The failure cases are ignored.
The loop problem. A while loop with a match inside is a common pattern for consuming a stream of optional values.
loop {
match iterator.next() {
Some(value) => process(value),
None => break,
}
}while let expresses this directly.
while let Some(value) = iterator.next() {
process(value);
}The loop continues while the pattern matches. When it does not match, the loop ends. The break is implicit.
The guard problem. Neither if let nor while let supports guards directly in the base form, but if let can be combined with an additional condition using && in Rust 2024, or with a nested if in earlier editions.
The exhaustiveness problem. if let and while let do not check exhaustiveness. If a new variant is added to an enum, the compiler does not warn that an if let somewhere is now ignoring it. This is the trade-off: less code, less safety. Use if let when the ignored cases are genuinely irrelevant; use match when every case should be handled.
a. if let syntax and patterns
The syntax is if let PATTERN = EXPRESSION { ... }. The expression is evaluated, the pattern is matched against the result, and the block runs if the pattern matches.
let config_value = Some(42);
if let Some(value) = config_value {
println!("Value: {}", value);
}The Some(value) pattern matches when config_value is Some, and binds the inner value to value. The block runs with value in scope.
An else clause handles the non-matching case:
if let Some(value) = config_value {
println!("Value: {}", value);
} else {
println!("No value");
}The else block runs when the pattern does not match. This is equivalent to a match with two arms, but reads more like an if.
An else if let chain handles multiple patterns:
if let Some(value) = config_value {
println!("Some: {}", value);
} else if let None = config_value {
println!("None");
}The chain is evaluated in order. The first matching pattern runs its block, and the rest are skipped.
The pattern can be any valid Rust pattern, not just Some and Ok. An enum variant:
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
}
let msg = Message::Move { x: 10, y: 20 };
if let Message::Move { x, y } = msg {
println!("Moving to ({}, {})", x, y);
}A tuple:
let point = (3, 5);
if let (0, y) = point {
println!("On y-axis at {}", y);
} else {
println!("Not on y-axis");
}A reference:
let value = Some(String::from("hello"));
if let Some(s) = &value {
println!("{}", s);
}The pattern matches through the reference, and s is a &String.
A binding with @:
let age = 25;
if let n @ 18..=65 = age {
println!("Working age: {}", n);
}The pattern binds age to n and checks that it is in the range.
b. while let syntax and loops
The syntax is while let PATTERN = EXPRESSION { ... }. The expression is evaluated, the pattern is matched, and the block runs while the pattern matches. When the pattern fails to match, the loop ends.
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("{}", top);
}The stack.pop() returns Some(value) while the stack is not empty and None when it is. The loop continues while pop() returns Some, printing each value. When the stack is empty, pop() returns None, the pattern fails, and the loop ends.
This is the idiomatic way to consume an iterator that returns Option:
let mut iter = vec![10, 20, 30].into_iter();
while let Some(value) = iter.next() {
println!("{}", value);
}The next() method returns Some(value) until the iterator is exhausted. The loop processes each value and ends when next() returns None.
A while let loop can be exited early with break and skipped with continue:
let mut stack = vec![1, 2, 3, 4, 5];
while let Some(top) = stack.pop() {
if top == 3 {
break;
}
if top % 2 == 0 {
continue;
}
println!("{}", top);
}The break exits the loop. The continue skips the rest of the iteration and returns to the condition.
The pattern in while let can be any pattern, not just Some:
let mut numbers = vec![1, 2, 3].into_iter().peekable();
while let Some(&n) = numbers.peek() {
if n > 2 {
break;
}
println!("{}", n);
numbers.next();
}The peek() method returns Some(&value) without consuming. The pattern Some(&n) dereferences and binds. The loop prints values until the peeked value exceeds 2.
A while let loop with a mutable reference:
let mut current = Some(Box::new(Node { value: 1, next: None }));
while let Some(node) = current {
println!("{}", node.value);
current = node.next;
}The pattern takes ownership of the node, prints its value, and moves to the next. The loop ends when current is None.
c. if let chains and the 2024 edition
Rust 2024 stabilized let chains, which allow if let to be combined with additional conditions using &&. This makes it possible to express patterns that previously required nested if statements.
let config = Some(42);
if let Some(value) = config && value > 10 {
println!("Large value: {}", value);
}The if let matches Some(value), and the && value > 10 adds a condition. Both must be true for the block to run. This is equivalent to a match guard, but in an if let form.
The chain can include multiple let patterns:
let user = Some(User { name: "Alice", age: 30 });
if let Some(user) = user && let Some(email) = user.email {
println!("Email: {}", email);
}The first pattern matches the user, and the second matches the email within the user. The block runs only when both match.
The chain can include boolean conditions between the patterns:
if let Some(user) = user && user.age >= 18 && let Some(email) = user.email {
println!("Adult with email: {}", email);
}This combines pattern matching and conditional logic in a single readable chain.
let chains require Rust 2024 edition. In earlier editions, the same logic requires nested if let or a match with guards:
// Before Rust 2024
if let Some(user) = user {
if user.age >= 18 {
if let Some(email) = user.email {
println!("Adult with email: {}", email);
}
}
}The let chain is flatter and reads as a sequence of conditions. It is one of the ergonomic improvements in Rust 2024.
while let does not support chains in the same way. The while let condition is a single pattern, and additional conditions must be expressed inside the loop body.
Complete Example Session
// ============================================
// PART 1: BASIC IF LET
// ============================================
let value = Some(42);
if let Some(v) = value {
println!("Value: {}", v);
}// ============================================
// PART 2: IF LET WITH ELSE
// ============================================
if let Some(v) = value {
println!("Value: {}", v);
} else {
println!("No value");
}// ============================================
// PART 3: ELSE IF LET CHAIN
// ============================================
let result: Result<i32, String> = Ok(42);
if let Ok(v) = result {
println!("Success: {}", v);
} else if let Err(e) = result {
println!("Error: {}", e);
}// ============================================
// PART 4: ENUM PATTERN
// ============================================
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
}
let msg = Message::Move { x: 10, y: 20 };
if let Message::Move { x, y } = msg {
println!("Moving to ({}, {})", x, y);
}// ============================================
// PART 5: TUPLE PATTERN
// ============================================
let point = (0, 5);
if let (0, y) = point {
println!("On y-axis at {}", y);
}// ============================================
// PART 6: BASIC WHILE LET
// ============================================
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("{}", top);
}// ============================================
// PART 7: WHILE LET WITH ITERATOR
// ============================================
let mut iter = vec![10, 20, 30].into_iter();
while let Some(value) = iter.next() {
println!("{}", value);
}// ============================================
// PART 8: WHILE LET WITH BREAK
// ============================================
let mut stack = vec![1, 2, 3, 4, 5];
while let Some(top) = stack.pop() {
if top == 3 {
break;
}
println!("{}", top);
}// ============================================
// PART 9: IF LET CHAIN (RUST 2024)
// ============================================
let config = Some(42);
if let Some(value) = config && value > 10 {
println!("Large value: {}", value);
}// ============================================
// PART 10: NESTED IF LET CHAIN
// ============================================
struct User {
name: String,
email: Option<String>,
}
let user = Some(User {
name: String::from("Alice"),
email: Some(String::from("alice@example.com")),
});
if let Some(u) = user && let Some(email) = u.email {
println!("Email: {}", email);
}The ten parts covered basic if let, else, else if let chains, enum patterns, tuple patterns, basic while let, iterators, break, let chains, and nested let chains.
Quick Reference
if let Syntax
| Form | Behavior |
|---|---|
if let PAT = EXPR { } | Runs block if pattern matches |
if let PAT = EXPR { } else { } | Runs else if pattern fails |
if let A = X { } else if let B = X { } | Chain of patterns |
if let PAT = EXPR && cond { } | Chain with condition (Rust 2024) |
while let Syntax
| Form | Behavior |
|---|---|
while let PAT = EXPR { } | Loops while pattern matches |
while let PAT = EXPR { break; } | Exits early |
while let PAT = EXPR { continue; } | Skips to next iteration |
if let vs match
| Aspect | if let | match |
|---|---|---|
| Exhaustiveness | Not checked | Checked |
| Arm count | One (plus else) | Any |
| Verbosity | Low | Higher |
| Use case | One pattern matters | All patterns matter |
| Guards | Via && (2024) | Native |
| Binding | Yes | Yes |
Common Patterns
| Pattern | Example |
|---|---|
Some(x) | if let Some(x) = opt |
Ok(x) | if let Ok(x) = result |
Err(e) | if let Err(e) = result |
| Enum variant | if let Message::Move { x, y } = msg |
| Tuple | if let (a, b) = pair |
| Range | if let n @ 1..=10 = x |
| Reference | if let Some(s) = &value |
Best Practices
✅ Do This:
// Use if let when only one pattern matters
if let Some(value) = config {
process(value);
} // ✅
// Use while let to consume an iterator
while let Some(item) = iter.next() {
process(item);
} // ✅
// Use else for the non-matching case
if let Ok(value) = result {
process(value);
} else {
handle_error();
} // ✅
// Use let chains in Rust 2024
if let Some(x) = opt && x > 0 {
process(x);
} // ✅
// Use match when every case matters
match result {
Ok(v) => process(v),
Err(e) => handle(e),
} // ✅
// Use if let for optional cleanup
if let Some(handle) = self.handle.take() {
handle.close();
} // ✅❌ Don’t Do This:
// Don't use if let when all cases matter
if let Ok(v) = result {
process(v);
}
// Err case silently ignored // ⚠️
// Don't nest if let unnecessarily
if let Some(x) = opt {
if let Some(y) = x.value {
// use y
}
}
// Use let chains instead // ⚠️
// Don't use while let when the loop should always terminate
while let Some(x) = infinite_source.next() {
process(x);
}
// Add a break condition // ⚠️
// Don't ignore the exhaustiveness trade-off
enum Status { A, B, C }
if let Status::A = status { }
// B and C silently ignored // ⚠️
// Don't use if let for simple boolean checks
if let true = condition { }
// Use if condition { } // ❌
// Don't forget the else when the failure case matters
if let Some(x) = opt { process(x); }
// Missing error handling // ⚠️Common Pitfalls
| Pitfall | Why It Happens | Fix |
|---|---|---|
| Silent case ignored | No exhaustiveness check | Use match if all cases matter |
Nested if let | No let chains in older edition | Use Rust 2024 or flatten with match |
while let never ends | Condition always matches | Add a break or a terminating condition |
| Pattern does not match | Wrong variant or type | Check the pattern against the value |
| Binding not in scope | Used outside the block | The binding is scoped to the block |
else missing | Non-matching case ignored | Add else if it matters |
Move in while let | Pattern consumes the value | Use & to match by reference |
Real-World Examples
1. Optional Configuration
if let Some(port) = config.port {
server.bind(port);
}2. Result Handling
if let Ok(data) = response.json() {
process(data);
}3. Consuming a Stack
while let Some(item) = stack.pop() {
process(item);
}4. Iterator Consumption
while let Some(line) = lines.next() {
parse(line);
}5. Enum Variant Check
if let Event::KeyPress(key) = event {
handle_key(key);
}6. Nested Option
if let Some(Some(value)) = nested {
println!("{}", value);
}7. Let Chain
if let Some(user) = user && user.is_active {
welcome(user);
}8. Early Exit
while let Some(item) = queue.pop() {
if item.is_poison() {
break;
}
process(item);
}9. Mutable Reference
if let Some(ref mut value) = self.cache {
*value += 1;
}10. Take and Handle
if let Some(handle) = self.handle.take() {
handle.shutdown();
}Visual
if let vs match
┌─────────────────────────────────────────────────────────────┐
│ MATCH │
│ │
│ match config { │
│ Some(value) => println!("{}", value), │
│ None => {} │
│ } │
│ │
│ Verbose. The None arm is noise. │
│ Exhaustiveness checked. │
│ │
├─────────────────────────────────────────────────────────────┤
│ │
│ IF LET │
│ │
│ if let Some(value) = config { │
│ println!("{}", value); │
│ } │
│ │
│ Concise. The None case is silently ignored. │
│ No exhaustiveness check. │
│ │
└─────────────────────────────────────────────────────────────┘while let vs loop-match
┌─────────────────────────────────────────────────────────────┐
│ LOOP WITH MATCH │
│ │
│ loop { │
│ match iter.next() { │
│ Some(value) => process(value), │
│ None => break, │
│ } │
│ } │
│ │
│ Explicit break. More code. │
│ │
├─────────────────────────────────────────────────────────────┤
│ │
│ WHILE LET │
│ │
│ while let Some(value) = iter.next() { │
│ process(value); │
│ } │
│ │
│ Implicit break when pattern fails. │
│ Concise. │
│ │
└─────────────────────────────────────────────────────────────┘Let Chain (Rust 2024)
┌─────────────────────────────────────────────────────────────┐
│ NESTED IF LET (BEFORE 2024) │
│ │
│ if let Some(user) = user { │
│ if user.age >= 18 { │
│ if let Some(email) = user.email { │
│ println!("{}", email); │
│ } │
│ } │
│ } │
│ │
│ Three levels of nesting. │
│ │
├─────────────────────────────────────────────────────────────┤
│ │
│ LET CHAIN (RUST 2024) │
│ │
│ if let Some(user) = user │
│ && user.age >= 18 │
│ && let Some(email) = user.email { │
│ println!("{}", email); │
│ } │
│ │
│ Flat. Each condition on its own line. │
│ │
└─────────────────────────────────────────────────────────────┘Exhaustiveness Trade-off
┌─────────────────────────────────────────────────────────────┐
│ enum Status { Active, Inactive, Pending } │
│ │
│ MATCH │
│ match status { │
│ Status::Active => { } │
│ Status::Inactive => { } │
│ Status::Pending => { } │
│ } │
│ ✓ Exhaustive. Adding a variant breaks compilation. │
│ │
├─────────────────────────────────────────────────────────────┤
│ │
│ IF LET │
│ if let Status::Active = status { } │
│ ✗ Inactive and Pending silently ignored. │
│ Adding a variant does not break compilation. │
│ │
└─────────────────────────────────────────────────────────────┘Summary
| Item | Value |
|---|---|
if let | Runs block if pattern matches |
else | Runs if pattern fails |
else if let | Chain of patterns |
while let | Loops while pattern matches |
break | Exits while let early |
continue | Skips to next iteration |
| Let chains | if let A = x && cond (Rust 2024) |
| Exhaustiveness | Not checked |
| Use case | One pattern matters |
Key takeaways:
if letis shorthand for amatchwith one meaningful arm. It runs a block when a pattern matches and ignores the rest. It is the right choice when only one variant or pattern is relevant.while letis shorthand for aloopwith amatchthat breaks on the non-matching case. It loops while a pattern matches, and the loop ends when the pattern fails. It is the idiomatic way to consume an iterator that returnsOption.elseandelse if lethandle the non-matching case. Withoutelse, the non-matching case is silently ignored. Withelse, it can be handled. The chain ofelse if lethandles multiple patterns in order.if letdoes not check exhaustiveness. If a new variant is added to an enum, the compiler does not warn that anif letis ignoring it. This is the trade-off for conciseness. Usematchwhen every case matters.- Patterns in
if letandwhile letare full Rust patterns. They can match enum variants, tuples, structs, ranges, references, and bindings with@. The pattern is the same as in amatcharm. while letis ideal for consuming iterators and stacks.while let Some(x) = iter.next()processes each element until the iterator is exhausted. Thepop()method on a stack works the same way.letchains in Rust 2024 flatten nestedif let. The&&operator combines pattern matches and boolean conditions in a singleif letcondition. This removes the nesting that previously required multiple levels ofif.- Use
if letfor optional cleanup and single-variant handling. Taking a value out of anOptionand processing it, or handling one variant of an enum while ignoring the rest, are the canonical use cases.
Remember: if let and while let are convenience constructs for the cases where a full match is more ceremony than the situation warrants. They handle one pattern and ignore the rest. if let runs a block when the pattern matches. while let loops while the pattern matches. Neither checks exhaustiveness, which is the trade-off: less code, less safety. Use them when the ignored cases are genuinely irrelevant. Use match when every case matters, and the compiler should tell you when the set of cases changes. The two constructs complement each other, and knowing when to use each is part of writing idiomatic Rust.
Stop using slow, ad-bloated tool sites! 🤮
🔎 Search “KandZ Tools” on Google to use many professional utilities for free.
KandZ.me is the ultimate minimalist hub for:
✅ Finance (Mortgage, Interest, Inflation)
✅ Tech (Base64, JSON, Dev Suite, IP)
✅ Health (BMI, BMR, TDEE)
✅ Productivity (Timer, Workspace, QR)
⚡️ Fast & Private
🔒 No data leaves your device
💎 100% Free
🔗 Use it now: https://tools.kandz.me
🔖 Bookmark it—you’ll need it later!