Control flow: if, loop, while and for

Decisions with if

Control flow decides which code runs and how many times. if runs a block only when a condition is true. In Rust, the condition must be a bool. You cannot write if count { ... } with a number like in C, Python or JavaScript; write if count != 0. This removes a whole class of bugs.

fn main() {
    let age = 20;
    if age >= 18 {
        println!("Can vote");
    } else if age >= 16 {
        println!("Can get a learner's licence soon");
    } else {
        println!("Too young");
    }
}

if is an expression

Because if produces a value, you can use it on the right side of let. Both branches must give the same type.

let is_member = true;
let delivery_fee = if is_member { 0 } else { 40 };
println!("Fee: {delivery_fee}");   // Fee: 0

// let x = if is_member { 0 } else { "free" };  // error: if and else have incompatible types

loop: repeat until break

loop repeats forever until you call break. You can also hand a value out of the loop: break value. This is handy for retrying something until it works.

let mut attempts = 0;
let result = loop {
    attempts += 1;
    if attempts == 3 {
        break attempts * 10;
    }
};
println!("{result}");   // 30

while: repeat while a condition holds

let mut seats = 3;
while seats > 0 {
    println!("{seats} seats left");
    seats -= 1;
}
println!("Sold out!");

for: the loop you will use most

for goes over each item of a collection or a range. A range is written start..end, which stops before end, or start..=end, which includes end. for loops cannot read past the end of a collection, so they are safer than counting with while.

for i in 1..=5 {
    print!("{i} ");          // 1 2 3 4 5
}
println!();
for i in (1..4).rev() {
    print!("{i} ");          // 3 2 1
}
println!();
let cities = ["Delhi", "Chennai", "Kolkata"];
for city in cities {
    println!("Train to {city}");
}

Loop labels

With nested loops, break and continue affect the innermost loop. To stop an outer loop, give it a label starting with an apostrophe and use break 'label.

'outer: for row in 1..=3 {
    for col in 1..=3 {
        if row * col == 4 {
            break 'outer;
        }
        print!("{} ", row * col);
    }
}
// prints: 1 2 3 2

Skipping a round with continue

continue jumps straight to the next round of the loop, skipping the rest of the body. It is useful for ignoring items you do not care about, such as blank lines in a file or cancelled orders in a list. Like break, it can take a label to skip a round of an outer loop.

for n in 1..=10 {
    if n % 2 == 0 {
        continue;     // skip even numbers
    }
    print!("{n} ");   // 1 3 5 7 9
}

Which loop should I use?

Most Rust code uses for. When you catch yourself writing a while loop with a counter variable that you increase by hand, a for loop over a range is usually shorter and safer.

Common mistakes

• if x = 5 instead of if x == 5. Assignment is not a bool, so Rust refuses to compile, which is good.
• Using 1..10 when you meant to include 10. Use 1..=10.
• Different types in if/else branches used as a value. Make both branches give the same type.
• An endless loop with no break. Every loop needs a way out.