Why does "break" not need a semicolon when ending a "loop"?

user_3873510 0
Viewed 802

Excerpt from Chapter 3.5 of the Rust Book:

we use the break keyword with the value counter * 2. After the loop, we use a semicolon to end the statement that assigns the value to result.

Plus the code snippet:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

I understand how this works and why the result is 20, but I noticed that if I remove the semicolon on the line that contains the break keyword, the program is equivalent.

Why is the semicolon optional in this case?

rust break syntax keyword loops
2 Answers

A shorter example:

let _: i32 = loop {
    if true {
        break 3; // ()
    }
};

That is just another example where the semi-colon does not interfere with the intended outcome. For one, the insertion of a semi-colon introduces an expression statement, which evaluates to the unit type (). As the loops and if expressions continue to admit a code block evaluating to the same type (), then all types are in conformance.

let _: i32 = loop {
    if true {
        break 3 // !
    }
};

If the semi-colon is taken away, the break is evaluated to the never type !, which coerces to any other type. This means that it will fulfill any type expected by the outer scope. So all is well all the same, so long as you don't try to append any other statement before the end of the if block.

Both break and return evaluate to !, as their side effects imply that the program will not go through with the natural workflow.

See also:

user_12332510

The Rust Language Reference on Expression Statements:

An expression statement is one that evaluates an expression and ignores its result. As a rule, an expression statement's purpose is to trigger the effects of evaluating its expression.

An expression that consists of only a block expression or control flow expression, if used in a context where a statement is permitted, can omit the trailing semicolon.

I imagine this is purely for aesthetics and ergonomics, since almost everything is an expression in Rust. If the trailing semicolon was mandatory after all expressions then we'd have to terminate if-else blocks (which are also expressions) with semicolons which looks terrible:

if {
    // do something
} else {
    // do something else
}; // <- gross

Similarly, we can omit the trailing semicolon on all control flow expressions because they produce control flow, so the typical function of the semicolon, which is to discard the expression's result and evaluate to () instead, becomes irrelevant.

fn five() -> i32 {
    return 5 // to semicolon or not to semicolon? it doesn't matter
}

In the above example it doesn't make a difference if we terminate return 5 with a semicolon or not since nothing can "capture" the result of that expression anyway since it produces control flow. Same would be true for other control flow expressions like break and continue.

user_27669080
Related