Rust Programming Language: Concise Control Flow with if let in Rust

In Rust, control flow is a crucial aspect of writing clean and efficient code. The `if let` syntax provides a concise and expressive way to handle values that match a specific pattern while ignoring others. This article explores the usage of `if let` as a more succinct alternative to the `match` expression, demonstrating its advantages and trade-offs.

The Verbosity of Match

Consider the following example, where we have an `Option<u8>` value in the `config_max` variable, and we want to execute code only if the value is of the `Some` variant:

Rust

let config_max = Some(3u8);
match config_max {
    Some(max) => println!("The maximum is configured to be {}", max),
    _ => (),
}

In this case, we use the `match` expression to handle the `Option<u8>` value. The pattern `Some(max)` binds the value inside the `Some` variant to the variable `max`, and we print it out. However, since we don't want to do anything with the `None` variant, we must add the `_ => ()` arm, introducing boilerplate code.

Enter if let

To achieve the same result in a more concise manner, we can use the `if let` syntax:

Rust

let config_max = Some(3u8);
if let Some(max) = config_max {
    println!("The maximum is configured to be {}", max);
}

The `if let` syntax combines the checking and binding of a pattern in a single line. Here, the pattern is `Some(max)`, and if the value in `config_max` matches this pattern, the code inside the block is executed. This eliminates the need for a separate arm to handle the `None` case, resulting in cleaner and more readable code.

Syntax Details

The `if let` syntax consists of a pattern and an expression separated by an equal sign. The pattern, similar to a `match` expression, is the condition to check against the expression. In our example, the pattern is `Some(max)`, where `max` is the variable binding to the value inside the `Some` variant.

Trade-offs: Conciseness vs. Exhaustiveness

While `if let` provides a more concise way to handle specific patterns, it lacks the exhaustive checking enforced by `match`. The `match` expression ensures that all possible cases are considered, preventing unintended oversight. Choosing between `match` and `if let` depends on the specific scenario and whether the gain in conciseness is an acceptable trade-off for losing exhaustive checking.

In essence, you can view `if let` as syntax sugar for a `match` expression that runs code when the value matches one pattern and ignores all other values.

Adding an Else Clause

You can extend the functionality of `if let` by adding an `else` clause. This is equivalent to the `_` arm in a `match` expression. For instance, let's revisit the example of counting non-quarter coins and announcing the state of quarters:

Rust

let mut count = 0;
if let Coin::Quarter(state) = coin {
    println!("State quarter from {:?}!", state);
} else {
    count += 1;
}

In this example, if the `coin` is a `Quarter`, we announce its state; otherwise, we increment the count of non-quarter coins.