Rust：`while true` 不能编译，但 `loop` 可以

Question

I am very new to Rust and to low-level languages in general. I noticed that in the code below, if I replace loop with while true the code doesn't compile anymore. I would actually expect the version with loop not to compile as well, because the return statement is inside an if statement, so not all code paths would return a value.

pub fn two_sum(numbers: Vec<i32>, target: i32) -> Vec<i32> {
    let mut left = 0;
    let mut right = numbers.len() - 1;
    loop {
        while numbers[left] + numbers[right] > target { 
            right -= 1;
        }
        if numbers[left] + numbers[right] == target {
            break vec![left as i32 + 1, right as i32 + 1];
        } else { 
            left += 1;
        }
    }
}

I am also open to suggestions on how to make the code above more Rust idiomatic!

Answer 1

That is because loop 's control flow is much better understood by the compiler:

• the compiler understands that a loop is executed at least once
• a loop without a break has type ! (never), which unifies with all types (in type-system lingo it's a "bottom" type), a loop with a break has type () , a loop with a valued break has whatever type break 's value has
• this means the compiler can reason about loop termination (or the lack thereof), if the loop does not contain a break statement it knows that the code following the loop is dead, it can never execute

None of that is the case of a while loop, there is no special-case for while true , or while false , they're not treated any differently than any other while loop: as far as the compiler is concerned they can all run for 0+ iterations

Hence:

let mut a;
loop {
    a = 1;
    break;
}
a

compiles but

let mut a;
while true {
    a = 1;
    break;
}
a

does not compile. That is also why loop can have a result value but while can not.