Control Flow

Rust provides if/else, three loop forms (loop, while, for), and exhaustive match. Loops and branches can produce values when used as expressions.

Recipe

fn sum_evens(nums: &[i32]) -> i32 {
    let mut total = 0;
    for &n in nums {
        if n % 2 == 0 {
            total += n;
        }
    }
    total
}
 
fn first_negative(nums: &[i32]) -> Option<i32> {
    for &n in nums {
        if n < 0 {
            return Some(n);
        }
    }
    None
}

When to reach for this: Any branching or iteration. Prefer for over while with manual index when iterating collections.

Working Example

fn find_pair(target: i32, nums: &[i32]) -> Option<(usize, usize)> {
    'outer: for i in 0..nums.len() {
        for j in (i + 1)..nums.len() {
            if nums[i] + nums[j] == target {
                break 'outer (i, j);
            }
        }
    }
}
 
fn retry<F: FnMut() -> bool>(mut f: F, max: u32) -> bool {
    let mut attempts = 0;
    loop {
        if f() {
            break true;
        }
        attempts += 1;
        if attempts >= max {
            break false;
        }
    }
}
 
fn main() {
    let nums = [2, 7, 11, 15];
    println!("{:?}", find_pair(9, &nums));
    println!("{}", retry(|| false, 3));
}

What this demonstrates:

• Labeled break 'outer exits nested loops with a tuple value
• loop with conditional break implements retry logic
• Range 0..nums.len() for index-based access when needed
• Option for absent results instead of sentinel values

Deep Dive

Loop Forms

let squares: Vec<i32> = (0..5).map(|n| n * n).collect();

match Exhaustiveness

enum Color { Red, Green, Blue }
 
fn hex(c: Color) -> &'static str {
    match c {
        Color::Red => "#f00",
        Color::Green => "#0f0",
        Color::Blue => "#00f",
    }
}

Compiler errors if a variant is missing. Use _ only when you intentionally catch remaining cases.

if let and while let

let Some(x) = opt else { return };
while let Some(line) = lines.next() {
    println!("{line}");
}

Ergonomic partial matching without full match.

Gotchas

• if condition not bool - if 1 { } fails. Fix: Use explicit comparisons.
• Off-by-one ranges - 0..n excludes n. Fix: Use 0..=n for inclusive end when needed.
• Borrowing in for loops - for item in &vec borrows; for item in vec moves. Fix: Choose iter(), iter_mut(), or into_iter() deliberately.
• Non-exhaustive match - Adding enum variants breaks compiles. Fix: Treat as a feature; update all matches.
• break value type mismatch - All break in a loop must return the same type. Fix: Annotate or unify types.

Alternatives

FAQs

Related

• Functions & Expressions - expression-oriented blocks
• Pattern Matching with match - deep match patterns
• if let, let else & while let - partial matches
• Iterator Adapters - loop-free transforms

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.