在“return”的末尾加上分号会有区别吗？

Question

《防锈指南》规定：

分号将任何表达式转换为语句，方法是丢弃其值并返回单位。

我以为我把这个概念记下来了，直到我做了一个实验：

fn print_number(x: i32, y: i32) -> i32 {
    if x + y > 20 { return x }      
    x + y 
}

编译得很好。然后，我在返回行的末尾添加了一个分号（return x；）。据我所知，这将该行转换为语句，返回单位数据类型。

尽管如此，最终结果是一样的。

Answer 1

我不是百分之百确定我在说什么，但这有点道理。

还有一个概念正在发挥作用：可达性分析。编译器知道返回表达式语句后面的内容是不可达的。例如，如果我们编译这个函数：

fn test() -> i32 {
    return 1;
    2
}

我们收到以下警告：

warning: unreachable expression
 --> src/main.rs:3:5
  |
3 |     2
  |     ^
  |

如果表达式以返回表达式结尾，编译器可以忽略if表达式的“true”分支，并且在确定if表达式的类型时只考虑“false”分支。

您还可以使用发散函数看到这种行为。发散函数是不正常返回的函数（例如它们总是失败）。尝试将返回表达式替换为失败！宏（扩展为对发散html" target="_blank">函数的调用）。事实上，返回表达式也被认为是发散的；这是前面提到的可达性分析的基础。

但是，如果在return语句之后有一个实际的表达式，您将得到一个错误。此功能：

fn print_number(x: i32, y: i32) -> i32 {
    if x + y > 20 {
        return x;
        ()
    } else {
        x + y
    }
}

给出以下错误：

error[E0308]: mismatched types
 --> src/main.rs:4:9
  |
4 |         ()
  |         ^^ expected i32, found ()
  |
  = note: expected type `i32`
             found type `()`

最后，当发散表达式后跟分号时，编译器似乎对发散表达式（包括返回表达式）的处理方式有所不同：语句仍在发散。

Answer 2

通常，if表达式中的每个分支都应该具有相同的类型。如果某个分支的类型未指定，编译器将尝试查找单个公共类型：

fn print_number(x: int, y: int) {
  let v = if x + y > 20 {
    3 // this can be either 3u, 3i, 3u8 etc.
  } else {
    x + y // this is always int
  };
  println!("{}", v);
}

在此代码中，3未指定，但ore分支强制它具有int的类型。

这听起来很简单：有一个函数将两种或多种类型“统一”为通用类型，或者当这不可能时它会给你一个错误。但是如果分支中出现失败！怎么办？

fn print_number(x: int, y: int) {
  let v = if x + y > 20 {
    fail!("x + y too large") // ???
  } else {
    x + y // this is always int
  };
  println!("{}", v); // uh wait, what's the type of `v`?
}

我希望它失败 不会影响其他分支，毕竟这是一种例外情况。由于这种模式在锈蚀中很常见，因此引入了分叉型的概念。不存在发散类型的值。（根据上下文，它也称为“无居民类型”或“无效类型”。不要与“单位类型”混淆，后者具有单个值由于发散类型自然是任何其他类型的子集，编译器得出结论，v的类型就是else分支int的类型。

返回表达式与失败！没有什么不同，用于类型检查。它突然从当前执行流中逃脱，就像失败！（但谢天谢地，不会终止任务）。尽管如此，发散类型不会传播到下一条语句：

fn print_number(x: int, y: int) {
  let v = if x + y > 20 {
    return; // this is diverging
    () // this is implied, even when you omit it
  } else {
    x + y // this is always int
  };
  println!("{}", v); // again, what's the type of `v`?
}

请注意，唯一的分号语句x相当于表达式x；（） 。通常<代码>a；b的类型与b的类型相同，所以x是很奇怪的；（）只有当x不发散时才有一种类型，当x发散时才有一种类型。这就是为什么您的原始代码不起作用。

添加这样的特殊情况很诱人：

• 为什么不做x；（）当x发散时发散

事实是，设计类型系统并不困难，但验证它要困难得多，我们希望确保Rust的类型系统是经久耐用的。如果它真的有用并且被证明对我们的目的是“正确的”，其中一些可能会发生，但不是立即发生。