是否有理由在编程语言中使用底部类型？

底部类型是一种主要出现在数学类型理论中的构造。也称为空类型。它是没有值的类型，但是是所有类型的子类型。

如果函数的返回类型是底部类型，则表示它不返回。期。也许它永远循环，或者抛出异常。

在编程语言中使用这种奇怪的类型有什么意义？这种情况并不常见，但是它存在于某些环境中，例如Scala和Lisp。

我举一个简单的例子：C ++ vs Rust。

这是一个用于在C ++ 11中引发异常的函数：

[[noreturn]] void ThrowException(char const* message,
                                 char const* file,
                                 int line,
                                 char const* function);

这等效于Rust：

fn formatted_panic(message: &str, file: &str, line: isize, function: &str) -> !;

在纯粹的语法问题上，Rust构造更为明智。请注意，即使C ++构造也指定了不返回，但它仍指定了返回类型。有点奇怪

从标准上讲，C ++语法仅与C ++ 11一起出现（位于最前面），但是各种编译器已经提供了一段时间的各种扩展，因此必须对第三方分析工具进行编程以识别各种方式​​。该属性可以被写入。对其进行标准化显然显然是优越的。

现在，至于好处呢？

函数不返回的事实可用于：

• 优化：可以修剪任何代码（不会返回），无需保存寄存器（因为无需恢复它们），...
• 静态分析：消除了许多潜在的执行路径
• 可维护性：（请参阅静态分析，但要人工操作）

卡尔的答案很好。这是我认为没有其他人提到的其他用途。的类型

if E then A else B

应该是一种类型，其中包含类型为的A所有值和类型为的所有值B。如果类型B为Nothing，则if表达式的类型可以为类型A。我会经常声明一个例程

def unreachable( s:String ) : Nothing = throw new AssertionError("Unreachable "+s) 

表示无法达到代码。由于其类型为Nothing，unreachable(s)因此现在可以在不影响结果类型的情况下以任何方式if（或更频繁地）switch使用。例如

 val colour : Colour := switch state of
         BLACK_TO_MOVE: BLACK
         WHITE_TO_MOVE: WHITE
         default: unreachable("Bad state")

Scala具有这种Nothing类型。

另一个用例Nothing（如卡尔的回答中所述）是List [Nothing]，即列表的类型，其成员的类型均为Nothing。因此，它可以是空列表的类型。

Nothing使这些用例起作用的关键特性不是它没有值-尽管在Scala中，它没有值-而是它是所有其他类型的子类型。

假设您有一种语言，其中每种类型都包含相同的值-称之为它()。用这种语言，具有()唯一价值的单位类型可以是每种类型的子类型。从OP的意义上来说，这并不能使其成为底层类型。OP很清楚，底部类型不包含任何值。但是，由于它是每个类型的子类型，因此它可以与底部类型扮演几乎相同的角色。

Haskell的处理方式有所不同。在Haskell中，从不产生值的表达式可以具有scheme类型forall a.a。这种类型方案的实例将与任何其他类型统一，因此即使（标准）Haskell没有子类型的概念，它也可以有效地作为底部类型。例如，error标准序言中的函数具有type scheme forall a. [Char] -> a。所以你可以写

if E then A else error ""

A对于任何表达式，表达式的类型将与的类型相同A。

Haskell中的空列表具有类型方案forall a. [a]。如果A是类型为列表类型的表达式，则

if E then A else []

是与类型相同的表达式A。

类型以两种方式形成一个单面体，一起构成一个半环。这就是所谓的代数数据类型。对于有限类型，此半环与自然数的半环（包括零）直接相关，这意味着您要计算该类型具有多少个可能的值（不包括“非终止值”）。

• 底部类型（我将其称为Vacuous）具有零值^†。
• 单位类型具有一个值。我将同时调用类型及其单个值()。
• 合成（大多数编程语言通过带有公共字段的记录/结构/类直接支持合成）是一种产品操作。举例来说，(Bool, Bool)有四个可能的值，即(False,False)，(False,True)，(True,False)和(True,True)。
  单元类型是合成操作的标识元素。例如((), False)和((), True)是type的唯一值((), Bool)，因此该类型与其Bool自身同构。
• 在大多数语言中，替代类型在某种程度上都被忽略了（OO语言有点支持继承），但是它们的作用也一样。两种类型之间的替代A，B基本上具有的所有值A加上的所有值B，因此为总和类型。举例来说，Either () Bool有三个值，我会打电话给他们Left ()，Right False和Right True。
  最下面的类型是sum的identity元素：仅Either Vacuous A具有形式的值，因为没有意义（没有值）。Right aLeft ...Vacuous

这些monoid的有趣之处在于，当您在语言中引入函数时，这些类型的类别以及以函数为形态的函数就是一个monoidal类别。除其他外，这使您可以定义应用函子和monad，这对于使用纯函数项的通用计算（可能涉及副作用等）来说是极好的抽象。

现在，实际上，您只需要担心问题的一侧（合成Monoid）就可以解决很多问题，那么您实际上并不需要明确地使用底部类型。例如，即使Haskell长期以来也没有标准的底部类型。现在，它叫做Void。

但是，当您将全图视为双笛卡尔封闭类别时，类型系统实际上等效于整个lambda演算，因此，基本上，您可以完美地抽象出图灵完备语言中的所有可能。非常适合嵌入式领域特定语言，例如，有一个有关以这种方式直接对电子电路进行编码的项目。

当然，您可能会说这是所有理论家的普遍废话。成为一名优秀的程序员，您根本不需要了解类别理论，但是当您这样做时，它就为您提供了强大而荒谬的通用方法来推理代码并证明不变式。

^† _{mb21提醒我注意，请勿将此与底值混淆。在像Haskell这样的惰性语言中，每种类型都包含一个表示为的底部“值” ⊥。这不是您可以显式传递的具体内容，而是例如函数永久循环时“返回的”内容。甚至Haskell的Void类型也“包含”底部值，因此也包含名称。因此，Haskell的底部类型确实具有一个值，而其单位类型具有两个值，但是在类别理论讨论中，通常将其忽略。}

也许它永远循环，或者抛出异常。

在这种情况下，听起来像是一种有用的类型，尽管可能很少。

而且，即使Nothing（Scala的底部类型名称）可以没有值，List[Nothing]也没有该限制，这使其可用作空列表的类型。大多数语言通过将空字符串列表与整数空列表作为不同类型来解决此问题，这种方式是有意义的，但会使空列表更冗长地编写，这在面向列表的语言中是一个很大的缺点。

对于静态分析而言，记录特定代码路径不可访问的事实非常有用。例如，如果您在C＃中编写以下代码：

int F(int arg) {
 if (arg != 0)
  return arg + 1; //some computation
 else
  Assert(false); //this throws but the compiler does not know that
}
void Assert(bool cond) { if (!cond) throw ...; }

编译器会抱怨F在至少一个代码路径中未返回任何内容。如果Assert将其标记为不可返回，则编译器将无需发出警告。

在某些语言中，null具有底部类型，因为所有类型的子类型都很好地定义了语言将null用作什么（尽管null既是自身又是返回自身的函数存在轻微的矛盾，避免了为何bot不宜居住的常见论点）。

它也可以用作函数类型（any -> bot）中的全部内容，以处理出错的调度。

并且某些语言允许您实际解决bot错误，可用于提供自定义编译器错误。

是的，这是一种非常有用的类型；虽然它的角色主要是类型系统的内部角色，但在某些情况下，底部类型会公开出现。

考虑以条件条件为表达式的静态类型语言（因此if-then-else构造是C和friends 的三元运算符的两倍，并且可能会有类似的多路case语句）。函数式编程语言具有此功能，但是它也发生在某些命令式语言中（自ALGOL 60起）。然后，所有分支表达式都必须最终产生整个条件表达式的类型。可以简单地要求它们的类型相等（我认为C中的三元运算符就是这种情况），但是这种限制过于严格，特别是当条件也可以用作条件语句（不返回任何有用的值）时。通常，人们希望每个分支表达式都是（隐式）可转换的 到将成为完整表达式类型的通用类型（可能具有或多或少的复杂限制，以允许编译器有效地找到通用类型，请参见C ++，但在此不再赘述）。

在两种情况下，通用类型的转换将允许这种条件表达式具有必要的灵活性。已经提到一种，结果类型是单位类型void; 这自然是所有其他类型的超类型，并且允许（平凡地）将任何类型转换为它，从而可以将条件表达式用作条件语句。另一种情况涉及表达式确实返回有用值，但是一个或多个分支无法产生一个值的情况。它们通常会引发异常或涉及跳转，并且要求它们（也）产生整个表达式的类型的值（从不可达的角度出发）将毫无意义。可以通过提供引发异常的子句，跳转和调用来优雅地处理这种情况，即底部类型，即可以（平凡地）转换为任何其他类型的一种类型。

我建议编写这样的底部类型，*以建议其可转换为任意类型。它可能在内部达到其他有用的目的，例如，当试图为没有声明任何递归的递归函数推导出结果类型时，类型推论者可以将该类型分配*给任何递归调用，以避免发生鸡与蛋的情况。实际类型将由非递归分支确定，并将递归分支转换为非递归分支的通用类型。如果根本没有非递归分支，则类型将保留*，并正确指示该函数没有从递归返回的任何可能方式。除此之外，作为异常抛出函数的结果类型，可以使用*作为长度为0的序列的组件类型，例如空列表；再次，如果从类型的表达式中选择了一个元素[*]（可能为空列表），那么生成的类型*将正确指示该元素永远不会返回而不会出现错误。

在某些语言中，您可以注释一个函数，以告知编译器和开发人员该函数的调用不会返回（并且如果该函数以可以返回的方式编写，则编译器将不允许它）。知道这很有用，但是最后您可以像其他任何函数一样调用这样的函数。编译器可以使用该信息进行优化，发出有关无效代码的警告，等等。因此，没有非常有说服力的理由拥有这种类型，但也没有非常有说服力的理由避免这种类型。

在许多语言中，函数可以返回“ void”。确切的含义取决于语言。在C语言中，这意味着该函数不返回任何内容。在Swift中，这意味着该函数返回的对象只有一个可能的值，并且由于只有一个可能的值，该值占用零位，并且实际上不需要任何代码。无论哪种情况，都与“底部”不同。

“底部”将是没有可能值的类型。它永远不会存在。如果函数返回“底部”，则它实际上无法返回，因为没有可以返回的“底部”类型的值。

如果语言设计师对此感到满意，那么就没有理由不使用这种类型。实现并不困难（您可以像返回void并标记为“不返回”的函数一样实现它）。您不能混合使用指向返回底部的函数的指针和指向返回void的函数的指针，因为它们不是同一类型）。