Control Flow Fundamentals

1. Conditional Branching: if Expressions

In Rust, like in most languages, if is used to execute code based on a condition. The basic syntax is straightforward.

let number = 7;

if number < 5 {
    println!("condition was true");
} else {
    println!("condition was false");
}

One important detail is that the condition must be a bool. Unlike some languages, Rust will not automatically convert non-boolean types. For example, if number { ... } where number is an integer will cause a compile-time error.

You can also handle multiple conditions with else if:

let number = 6;

if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3"); // This will be printed
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

Rust executes the block for the first true condition it finds and then skips the rest. If you find yourself with a long chain of else if statements, Rust provides a more powerful construct called match, which we will cover in detail in a future module on enums.

if is an Expression

Here is where Rust's philosophy shines. Because if is an expression, you can use it on the right side of a let statement to assign its result to a variable. This often eliminates the need for temporary mutable variables.

To understand the design principle behind this, the following article provides excellent context.

With that conceptual foundation, let's look at the practical rules in the official Rust documentation.

Here's an example of using if in a let binding:

let condition = true;
let number = if condition { 5 } else { 10 }; // number is 5

println!("The value of number is: {number}");

This is concise and leverages Rust's type system to ensure correctness at compile time. The following would fail to compile because the arms have incompatible types:

// This code does NOT compile!
let number = if condition { 5 } else { "ten" };

2. Repetition with Loops

Rust provides three looping constructs, each suited for different situations: loop, while, and for.

The loop Keyword

The loop keyword creates an infinite loop. You continue executing the code within it until you explicitly tell it to stop using the break keyword.

A loop can also be used as an expression to return a value. You provide the return value after the break keyword. This is useful for retrying operations that might fail.

Here is the example from the book, which demonstrates this feature:

let mut counter = 0;

let result = loop {
    counter += 1;

    if counter == 10 {
        break counter * 2; // The loop ends, and `counter * 2` is returned.
    }
};

println!("The result is {result}"); // Prints "The result is 20"

The while Conditional Loop

When you need to loop as long as a condition is true, a while loop is a more direct tool than a loop with an if-break. Since you're familiar with while from Python and Swift, we'll just focus on its form in Rust.

let mut number = 3;

while number != 0 {
    println!("{number}!");
    number -= 1;
}

println!("LIFTOFF!!!");

This is cleaner and less error-prone than manually managing the break condition inside an infinite loop.

The for Loop: The Idiomatic Choice for Iteration

The for loop is used to iterate over a collection of items, such as an array, a range, or any other type that implements the Iterator trait (which we'll explore in depth later). In idiomatic Rust, it is the most common and preferred loop.

Your experience with Python's for item in sequence: construct maps directly to Rust's for loop.

The key advantages of using a for loop for iteration are:

1. Safety: It eliminates the possibility of off-by-one errors or trying to access an index that is out of bounds, as the compiler handles the iteration logic.
2. Clarity: The intent to iterate over every element is explicit.
3. Performance: The compiler can often optimize for loops better than manual index-based while loops because it doesn't need to add runtime checks for bounds on every iteration.

Here are two common ways to use a for loop:

// Looping over an array's elements
let a = [10, 20, 30, 40, 50];

for element in a {
    println!("the value is: {element}");
}

// Looping over a range of numbers
// Note: `1..4` is a range that includes 1, 2, and 3, but excludes 4.
for number in 1..4 {
    println!("{number}!");
}

3. Seeing it All in Action

Now that we've covered the concepts and idiomatic usage, let's watch a video that provides a quick, practical demonstration of all these control flow constructs.

Conclusion

In this lesson, we've explored Rust's essential tools for controlling the flow of execution. While the concepts are universal in programming, Rust's implementation has some distinct characteristics that encourage writing safe, concise, and expressive code.

Here are the key takeaways:

• Control flow constructs like if and loop are expressions in Rust, allowing them to return values that can be assigned to variables.
• All branches of an if/else expression must evaluate to the same type.
• Rust has three kinds of loops:
  • loop for infinite loops, which can break with a value.
  • while for looping as long as a condition is true.
  • for for iterating over a collection, which is the safest and most idiomatic choice for that task.

In our next lesson, we will learn how to define our own functions. You'll see how Rust's expression-oriented nature extends to function bodies, allowing for elegant and implicit return values.