Rust函数声明返回u8，编译时却提示期望unit类型，原因何在？

问题代码 #

用户编写的示例代码：

fn main() {
    let exit: u8 = loop_break(20, 5);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 35);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 20);
    println!("loop_break exited with value {exit}");
}

fn loop_break(cycles: u8, exit: u8) -> u8 {

    if exit > cycles {
        cycles
    }

    let mut _i:u8 = 0;
    loop {
        if _i == exit {
            break exit - 1;
        }
        _i += 1;
    }
    return _i;
}

编译错误 #

编译时出现的错误信息：

error[E0308]: mismatched types
  --> src/main.rs:23:9
   |
22 | /     if exit > cycles {
23 | |         cycles
   | |         ^^^^^^ expected `()`, found `u8`
24 | |     }
   | |_____- expected this to be `()`
   |
help: you might have meant to return this value
   |
23 |         return cycles;
   |         ++++++       +

error[E0308]: mismatched types
  --> src/main.rs:29:19
   |
29 |             break exit - 1;
   |                   ^^^^^^^^ expected `()`, found `u8`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `flow-control` due to 2 previous errors

错误原因分析 #

1. if块的类型不匹配 #

Rust中if是表达式，若没有对应的else分支，该表达式默认返回()（unit类型）。你的函数声明返回u8，但你在if exit > cycles分支中直接写cycles（u8类型）却未用return，编译器会认为这个if表达式的结果需要与后续代码的上下文兼容——但后续还有代码执行，此时if块没有else的情况下，默认要返回()，和你写的cycles类型冲突，因此报错。

2. break带值的类型不匹配 #

普通loop若未被用作返回值的载体，默认返回()。你在break后附带了exit - 1（u8类型），但后续还有return _i;的逻辑，这不仅导致break的返回值类型与loop默认的()不匹配，同时逻辑上也存在矛盾：break执行后会跳出循环，后续的return _i;不会被执行，你附带的exit -1也无法被使用。

修正后的代码 #

方式一：使用return提前返回 #

fn main() {
    let exit: u8 = loop_break(20, 5);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 35);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 20);
    println!("loop_break exited with value {exit}");
}

fn loop_break(cycles: u8, exit: u8) -> u8 {
    if exit > cycles {
        // 提前返回，避免if表达式类型冲突
        return cycles;
    }

    let mut _i: u8 = 0;
    loop {
        if _i == exit {
            // 直接返回目标值，无需给break带值
            return exit - 1;
        }
        _i += 1;
    }
}

方式二：用if-else表达式统一返回类型 #

fn main() {
    let exit: u8 = loop_break(20, 5);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 35);
    println!("loop_break exited with value {exit}");
    let exit: u8 = loop_break(20, 20);
    println!("loop_break exited with value {exit}");
}

fn loop_break(cycles: u8, exit: u8) -> u8 {
    if exit > cycles {
        cycles
    } else {
        let mut _i: u8 = 0;
        // 让loop返回值作为else分支的结果，统一为u8类型
        loop {
            if _i == exit {
                break exit - 1;
            }
            _i += 1;
        }
    }
}

原理说明 #

• 方式一通过return提前退出函数，让if分支无需参与后续表达式的类型推导，直接满足函数返回u8的要求。
• 方式二给if补充else分支，让整个if-else表达式的返回值统一为u8类型，loop中break带的u8值作为else分支的结果，最终整个函数返回该表达式的值，符合类型要求。

内容的提问来源于stack exchange，提问作者Ulisse Rubizzo