Conditions and loops

Three ways to repeat, and a name for each loop

In “Variables, functions and control flow” you already used if and for informally, without naming why if produces a value or that two other ways to repeat exist. Here we complete the vocabulary: loop, while, and for cover different cases, and ranges, labels, and break/continue give you fine control over when to stop.

This vocabulary reappears through the rest of the course: iterators, match, and later the ? operator all build on the same expression and control-flow ideas you see here.

You will go through four stations: if as an expression, the three ways to repeat, ranges and labels, and the two ways to exit a loop.

CONDITION · n < 0Boolean result
PATH · both branches: i32same type in both branches
RESULT · clamp_lowclamp_low(-5), clamp_low(5)

01 / 04IF · ELSE · SAME TYPE

Both branches of if must produce the same type

if is not just a branch: it is an expression, and it produces a value. That is why you can assign its result directly with let. But there is a strict condition: both branches must produce exactly the same type.

Both branches of an if-expression must produce the same type.

lib.rsCompiles↗

/// `if` is an expression: both branches must produce the same type, and
/// the result can be bound with `let`.
#[must_use]
pub fn clamp_low(n: i32) -> i32 {
    let value = if n < 0 { 0 } else { n };
    value
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", clamp_low(-5), clamp_low(5));
}

Result

If the types do not match, the compiler cannot decide what type to give the variable.

lib.rsDoes not compile↗

fn main() {
    let n = 5;
    let label = if n > 0 { "positive" } else { 0 }; // ERROR: branches must match
    println!("{label}");
}

Result

The compiler says (E0308)

`if` and `else` have incompatible types. One branch produces &str and the other an integer.

error[E0308]: `if` and `else` have incompatible types
--> src/main.rs:3:48
|
3 |     let label = if n > 0 { "positive" } else { 0 };
|                            ----------          ^ expected `&str`, found integer
|                            |
|                            expected because of this

loop, while, and for cover different cases

loop repeats indefinitely until an explicit break: use it when you do not know in advance how many turns you will need. while checks a condition before each turn. for walks directly over a range, one turn per element, with no counter for you to manage.

If you can describe in advance what you are going to walk over, for is almost always the clearest choice.

lib.rsCompiles↗

/// `loop` repeats until an explicit `break`.
#[must_use]
pub fn count_to_three() -> i32 {
    let mut count = 0;
    loop {
        count += 1;
        if count == 3 {
            break;
        }
    }
    count
}

/// `while` checks its condition before every iteration.
#[must_use]
pub fn count_down(mut n: i32) -> i32 {
    while n > 0 {
        n -= 1;
    }
    n
}

/// `for` iterates directly over a range.
#[must_use]
pub fn sum_range(start: i32, end: i32) -> i32 {
    let mut total = 0;
    for n in start..end {
        total += n;
    }
    total
}

// Playground entry point for this example.
fn main() {
    println!("{} {} {}", count_to_three(), count_down(3), sum_range(1, 4));
}

Result

A label identifies which loop should break

You already used ranges like 1..5 (excludes the end) or 1..=5 (includes it). When you nest loops, a plain break only exits the innermost one. To exit an outer loop directly, you put an apostrophe label, like 'outer, in front of it, and write break 'outer from wherever you want to cut.

lib.rsCompiles↗

/// Searches a small grid for the first pair that sums to `target`,
/// breaking out of both loops at once with the `'outer` label.
#[must_use]
pub fn first_pair_summing_to(target: i32) -> Option<(i32, i32)> {
    let mut found = None;

    'outer: for a in 1..5 {
        for b in a..5 {
            if a + b == target {
                found = Some((a, b));
                break 'outer;
            }
        }
    }

    found
}

// Playground entry point for this example.
fn main() {
    println!("{:?}", first_pair_summing_to(7));
}

Result

continue skips to the next turn; break can carry a value

continue cuts the current turn and jumps straight to the next one, without running the rest of the loop body. break, for its part, does not just end a loop: it can carry a value with it, and that value becomes the result of the whole loop.

lib.rsCompiles↗

/// `continue` skips straight to the next iteration without running the
/// rest of the loop body.
#[must_use]
pub fn sum_even_up_to(limit: i32) -> i32 {
    let mut total = 0;
    for n in 1..=limit {
        if n % 2 != 0 {
            continue;
        }
        total += n;
    }
    total
}

/// `break` can carry a value out of `loop`; that value becomes the result.
#[must_use]
pub fn first_square_over(threshold: i32) -> i32 {
    let mut n = 0;
    loop {
        n += 1;
        let square = n * n;
        if square > threshold {
            break square;
        }
    }
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", sum_even_up_to(10), first_square_over(50));
}

Result

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Objective

Complete collatz_steps so it counts the steps: if n is even, divide by 2; if odd, compute 3 * n + 1. Repeat until n equals 1 and return the number of steps taken.

Implement

Replace `todo!` with a `while n != 1` loop and an `if`/`else` for even/odd.

Repeat the even/odd rule until reaching 1, counting one turn for each step applied.

/// Counts the steps the Collatz sequence takes to reach 1 from `start`.
pub fn collatz_steps(start: u64) -> u32 {
    todo!("loop while n != 1: even -> n / 2, odd -> 3 * n + 1, count each step")
}

Check

Run the visible cases and use the diagnostic to correct the code.

Visible tests

counts the correct steps for several known sequences

Compiler—

Modify the code before running the tests.

Help

View progressive hints or compare with the solution.

Commented solutionSolution↗

/// Counts the steps the Collatz sequence takes to reach 1 from `start`.
#[must_use]
pub fn collatz_steps(start: u64) -> u32 {
    let mut n = start;
    let mut steps = 0;

    while n != 1 {
        if n % 2 == 0 {
            n /= 2;
        } else {
            n = 3 * n + 1;
        }
        steps += 1;
    }

    steps
}

// Playground entry point for this example.
fn main() {
    println!("{}", collatz_steps(6));
}

Result

Summary

if is an expression: it produces a value, and its two branches must have the same type.
loop repeats until an explicit break; while checks its condition before each turn; for walks a range or iterator.
Ranges ../..= exclude or include the end; a label ('outer) identifies which loop should break when several are nested.
break 'label exits the outer loop directly, with no extra flags.
continue jumps to the next turn without running the rest of the body.
break value ends a loop and that value becomes the result of the loop.

Sources

The Rust Programming Languagech03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
Comprehensive Rustcontrol_flow · Geisler y colaboradores (Google)
Rust by Exampleflow_control

Three ways to repeat, and a name for each loop

Count how many steps a Collatz sequence takes to reach 1.

Implement

Count the Collatz steps

Check

Help

Summary

Sources