什么是永不归类？

What does a func with return type Never do?

具有返回类型的函数从不做什么？

For example:

例如：

func addNums() -> Never {

    //my code

}

What will be the difference if I kept the return type as Void like this?

如果我像这样保留返回类型为Void会有什么不同？

func addNums() -> Void {

    //my code

}

---

Suppose I wish to handle a fatalError (as said by dpassage); the below code will be sufficient:

假设我希望处理一个fatalError（如dpassage所说）;以下代码就足够了：

print("its an error")
return

Apple documentation says:

Apple文档说：

The return type of functions that do not return normally, that is, a type with no values.

不正常返回的函数的返回类型，即没有值的类型。

^{Source: Developer}

资料来源：开发商

This was not a duplicate question of When and how to use @noreturn attribute in Swift?, as I wish for a more detailed answer which needs details like:

这不是关于何时以及如何在Swift中使用@noreturn属性的重复问题，因为我希望得到更详细的答案，需要以下细节：

1. Practical examples on the difference between both Never and Void as return types

   关于Never和Void作为返回类型之间差异的实际示例

2. Condition by which we should adopt these return types.

   我们应该采用这些回报类型的条件。

3. Also there is a chance the return type can be nil; I need a comparison of that feature too

   返回类型也有可能为零;我也需要对这个功能进行比较

The answer should focus on the differences.

答案应该集中在差异上。

4 个解决方案

#1

Never return type was introduced in Swift 3 to substitute @noreturn key.

从未在Swift 3中引入返回类型来替换@noreturn键。

See justification in this proposal:
SE-0102 Remove @noreturn attribute and introduce an empty Never type

请参阅此提案中的理由：SE-0102删除@noreturn属性并引入空的Never类型

As official documentation explains:

正如官方文件所述：

The return type of functions that do not return normally; a type with no values.

返回类型的函数不能正常返回;没有值的类型。

Use Never as the return type when declaring a closure, function, or method that unconditionally throws an error, traps, or otherwise does not terminate.

在声明无条件抛出错误，陷阱或以其他方式终止的闭包，函数或方法时，使用Never作为返回类型。

_{Source: https://developer.apple.com/documentation/swift/never}

资料来源：https：//developer.apple.com/documentation/swift/never

Basic illustration:

基本插图：

// The following function is our custom function we would use
// to manually and purposefully trigger crash. In the logs,
// we can specify what exactly went wrong: e.g. couldn't cast something, 
// couldn't call something or some value doesn't exist:
func crashApp() -> Never {
    fatalError("Something very, very bad happened! Crash the app!")
}

Usage specifics and advantages over @noreturn, as referenced by Erica Sadun:

由Erica Sadun引用的@noreturn的用法细节和优势：

• Never allows a function or method to throw: e.g. () throws -> Never. Throwing allows a secondary path for error remediation, even in functions that were not expected to return.
• 从不允许函数或方法抛出：例如（）抛出 - >从不。抛出允许辅助路径进行错误修复，即使在预期不会返回的函数中也是如此。
• As a first class type, Never works with generics in a way that the @noreturn attribute could not.
• 作为第一类类型，永远不会以@noreturn属性不能的方式使用泛型。
• Never proactively prevents a function from claiming both a return type and no-return at the same time. This was a potential issue under the old system.
• 切勿主动阻止功能同时声明返回类型和不返回。这是旧系统下的潜在问题。

First note (regarding secondary error remediation) is probably particularly important. Never function can have complex logic and throw – not necessarily crash.

第一个注释（关于二级错误修复）可能特别重要。从来没有功能可以有复杂的逻辑和抛出 - 不一定崩溃。

Let's see some interesting use cases and comparison between Never and Void

让我们看一些有趣的用例以及Never和Void之间的比较

Never

Example 1

例1

func noReturn() -> Never {
    fatalError() // fatalError also returns Never, so no need to `return`
}

func pickPositiveNumber(below limit: Int) -> Int {
    guard limit >= 1 else {
        noReturn()
        // No need to exit guarded scope after noReturn
    }
    return rand(limit)
}

Example 2

例2

func foo() {
    abort()
    print("Should not reach here") // Warning for this line
}

Example 3

例3

func bar() -> Int {
    if true {
        abort() // No warning and no compiler error, because abort() terminates it.
    } else {
        return 1
    }
}

abort() is defined as:

abort（）定义为：

public func abort() -> Never

Void

These examples would not have been possible with it returning Void:

返回Void时，这些例子是不可能的：

public func abortVoid() -> Void {
    fatalError()
}

func bar() -> Int {
    if true {
        abortVoid() // ERROR: Missing return in a function expected to return 'Int'
    } else {
        return 1
    }
}

And to pack it up with abort() returning Never:

并使用abort（）将其打包返回Never：

func bar() -> Int {
    if true {
        abort() // No ERROR, but compiler sees it returns Never and warns:
        return 2 // Will never be executed
    } else {
        return 1
    }
}

We use Void to tell compiler there is no return value. Application keeps running.

我们使用Void告诉编译器没有返回值。应用程序继续运行

We use Never to tell compiler there is no return to caller site. Application runloop is terminated.

我们使用Never告诉编译器没有返回调用者站点。应用程序runloop终止。

#2

Void

空虚

Void is itself a return type which is tupple with zero element. You can use Void and () interchangeably.

Void本身就是一个返回类型，它是一个零元素的tupple。您可以互换使用Void和（）。

Look at this examples,

看看这个例子，

1. func yourFunc() {} This is function without return type, which basically returns tupple with zero element, that can be written as ()

   func yourFunc（）{}这是没有返回类型的函数，它基本上返回带有零元素的tupple，可以写成（）

2. func yourFunc() -> Void {} Function which is explicitly informing compiler about return type of void

   func yourFunc（） - > Void {}显式通知编译器返回void类型的函数

3. func yourFunc() -> () {} This return type of () displays same as void type. () indicates tupple with zero element

   func yourFunc（） - >（）{}此返回类型（）显示与void类型相同。 （）表示具有零元素的tupple

Never

决不

Never return-type informs compiler that even no need to return empty tuple () also as function with never return type is used for the exit point for current execution like crash, fatal error, abort or exit.

永远不会返回类型通知编译器甚至不需要返回空的tuple（），因为函数具有从不返回类型用于当前执行的退出点，如崩溃，致命错误，中止或退出。

For detail understanding of never, let's have a look at abort() example :

有关never的详细了解，让我们看一下abort（）示例：

1.

1。

 func yourFunc() {
    abort()
    print("Will not reach at this point") //Warning for this line
} 

2.

2。

 func yourFunc() -> Int {
    if true {
        abort()
    } else {
        return 1
    }
}

From above code snippets, we can see when we call abort() (which doesn't return a value) as the last statement in a function that expects a value to be returned (in our case Int), the compiler doesn't generate a warning.

从上面的代码片段中，我们可以看到当我们调用abort（）（它不返回一个值）作为函数中的最后一个语句时，它要求返回一个值（在我们的例子中是Int），编译器不会生成一个警告。

abort()

中止（）

public func abort() -> Never

Similarly for exit():

类似于exit（）：

public func exit(_: Int32) -> Never

The apple documentation says: "Use Never as the return type when declaring a closure, function, or method that unconditionally throws an error, traps, or otherwise does not terminate."

Apple文档说：“在声明无条件抛出错误，陷阱或以其他方式终止的闭包，函数或方法时，使用Never作为返回类型。”

So if you want to write custom function that logs a catastrophic error, you should use the return type Never to signal to the compiler:

因此，如果您想编写记录灾难性错误的自定义函数，则应使用返回类型Never来向编译器发出信号：

func catastrophicErrorDisplay(error: String) -> Never {
    DisplaySomeCustomLogFacility(error)
}

In short "Never is used for sudden and total failure from which recovery is impossible."

简而言之，“永远不会用于突然和完全失败，无法从中恢复。”

#3

Never indicates that the function will never return. It's intended to be used for things like fatalError which cause your program to crash intentionally, often after logging an error. You probably shouldn't use it unless you're doing something like making a handler for catastrophic errors in your application.

永远不会表示该功能永远不会返回。它旨在用于fatalError之类的事情，这会导致程序故意崩溃，通常是在记录错误之后。你可能不应该使用它，除非你正在为你的应用程序中的灾难性错误做一个处理程序。

This is different from a function which just doesn't return a value, as in your second snippet. You could also write that as func addNums() -> Void.

这与不返回值的函数不同，就像在第二个代码段中一样。您也可以将其写为func addNums（） - > Void。

#4

To better understand Never and Void, and how Never is useful in more contexts than the old @noreturn was, let's first look at what the two types actually are defined as:

为了更好地理解Never和Void，以及Never如何在比旧的@noreturn更多的上下文中有用，让我们首先看看这两种类型实际定义为：

---

Never is defined here as:

这里从未定义为：

public enum Never {}

Since there is no way to instantiate a value of an empty enum, the type system guarantees that no instance of Never can exist. This means functions that specify their return type as Never are prevented by the type system from actually returning under any circumstances.

由于无法实例化空枚举的值，因此类型系统保证不存在Never的实例。这意味着类型系统在任何情况下都会阻止将其返回类型指定为Never的函数实际返回。

The compiler takes this into account when doing control-flow analysis. For example, these two functions both compile without error, whereas they would fail if a function that returns Void was substituted for fatalError:

编译器在进行控制流分析时会考虑到这一点。例如，这两个函数都编译时没有错误，而如果返回Void的函数替换为fatalError，它们将失败：

func foo(fail: Bool) -> String {
    if fail {
        fatalError()
    } else {
        return "foo"
    }
    // notice there is no return statement here
}

func bar(fail: Bool) -> Void {
    let s: String
    if fail {
        fatalError()
        // the compiler doesn't complain s is not initialized here
    } else {
        s = "bar"
    }
    print(s)
}

---

Void is defined here as:

Void在这里定义为：

public typealias Void = ()

There are no two different instances of an empty tuple. Thus, the return value of functions returning Void holds no information.

空元组没有两个不同的实例。因此，返回Void的函数的返回值不包含任何信息。

You can actually write return () or return Void(). You can also use the "value" returned, like this:

您实际上可以编写return（）或返回Void（）。您还可以使用返回的“值”，如下所示：

func empty() -> Void {}
let v = empty()
print(type(of: v)) // prints "()"

although the compiler will warn "Constant 'v' inferred to have type 'Void', which may be unexpected".

虽然编译器会警告“常量'v'推断出类型为'Void'，这可能是意料之外的”。

---

Defining both Never and Void in terms of the type system rather than as special language features enables us to do some pretty clever things with generics. Let's look at an example of a Result type, generic over both the success and failure type.

根据类型系统而不是特殊语言特性来定义Never和Void使我们能够使用泛型做一些非常聪明的事情。让我们看一下Result类型的示例，它是成功和失败类型的通用类型。

enum Result<R, E> {
    case success(R)
    case failure(E)
}

A possible specialization of this would be Result<Void, MyError>. This would mean you have a result that, on success, does not hold any information beyond the fact it succeeded.

可能的专业化是Result 。这意味着你的结果是，在成功的情况下，除了成功的事实之外，没有任何信息。 ，myerror>

Another possibility could be Result<String, Never>. This result is guaranteed by the compiler to never be the failure case.

另一种可能是Result 。编译器保证这个结果永远不会失败。 ，never>

Optionals interact with Never and Void in a similar way. Never? can only ever be nil, and Void? only holds the information wether it is nil or not, nothing more (it's basically a more complicated Bool). Both of these are not very useful on their own, but might appear when Never or Void are used as generic parameters somewhere.

Optionals以类似的方式与Never和Void交互。决不？只能是零和虚空？只保留信息，无论是否为零，仅此而已（基本上是一个更复杂的Bool）。这两者本身并不是很有用，但是当Never或Void在某处被用作通用参数时可能会出现。

---

In practice, you will rarely write functions returning Never. I have personally used it to wrap fatalError to create a function I use to mark functions that are not implemented yet:

在实践中，您很少会编写返回Never的函数。我个人用它来包装fatalError来创建一个我用来标记尚未实现的函数的函数：

func unimplemented(f: String = #function) -> Never {
    fatalError("\(f) is not implemented yet")
}

Another example of a function returning Never is dispatchMain(), which can be used in command-line utilities to start the DispatchQueue.main. Since this queue then waits for new blocks, dispatchMain() never returns.

返回Never的函数的另一个示例是dispatchMain（），它可以在命令行实用程序中用于启动DispatchQueue.main。由于此队列等待新块，dispatchMain（）永远不会返回。