Rust中的函数发散有什么意义？

Question

我已经阅读了一些答案，并收集了以下用例：

• 当一个函数慌了！s
• 当一个函数有无限循环时

但是我仍然不清楚为什么我们需要这样定义函数：

fn func() -> ! {
    panic!("Error!");
}

如果它的工作方式与此相同（没有感叹号）：

fn func() {
    panic!("Error!");
}

同时，为什么我们需要使用 在具有无限循环的函数中？看起来这个签名没有带来任何实际的使用信息。




Answer 1

编译器知道任何跟随发散表达式（w. r. t.求值顺序）的东西都是不可访问的。当决定局部变量是否初始化时，它可以使用这些信息来避免假否定。

考虑以下示例：

use rand; // 0.8.4

fn main() {
    let foo;
    if rand::random::<bool>() {
        foo = "Hello, world!";
    } else {
        diverge();
    }
    println!("{foo}");
}

fn diverge() {
    panic!("Crash!");
}

我们声明了一个变量foo，但我们只在if表达式的一个分支中初始化它。编译失败，出现以下错误：

error[E0381]: borrow of possibly-uninitialized variable: `foo`
  --> src/main.rs:10:15
   |
10 |     println!("{foo}");
   |               ^^^^^ use of possibly-uninitialized `foo`

但是，如果我们更改发散函数的定义，如下所示：

fn diverge() -> ! {
    panic!("Crash!");
}

然后代码成功编译。编译器知道如果执行else分支，它将永远不会到达println 因为发散（）发散。因此，else分支未初始化foo不是错误。

Answer 2

这些签名之间的主要区别归结为这样一个事实：可以强制为任何其他类型，因此与任何其他类型兼容（因为此代码路径从未被采用，所以我们可以假定它属于我们需要的任何类型）。当我们有多个可能的代码路径时，例如if-else或match，这一点很重要。

例如，考虑以下（可能是人为的，但希望足够清楚）代码：

fn assert_positive(v: i32) -> u32 {
    match v.try_into() {
        Ok(v) => v,
        Err(_) => func(),
    }
}

当func被声明为返回时 ，此函数编译成功。如果删除返回类型，func将声明为返回（），编译中断：

error[E0308]: `match` arms have incompatible types
 --> src/main.rs:8:19
  |
6 | /     match v.try_into() {
7 | |         Ok(v) => v,
  | |                  - this is found to be of type `u32`
8 | |         Err(_) => func(),
  | |                   ^^^^^^ expected `u32`, found `()`
9 | |     }
  | |_____- `match` arms have incompatible types

您还可以将其与Result:：unwrap的定义进行比较：

pub fn unwrap(self) -> T {
    match self {
        Ok(t) => t,
        Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", &e),
    }
}

这里，unwrap_failed正在返回！，因此它与在Ok大小写中返回的任何类型相统一。