What is the Never return type?

Question

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?

func addNums() -> Void {      //my code  } 

---

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

print("its an error") return 

Apple documentation says:

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:

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

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.

Answer 1

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

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

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.

_{Source: 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:

• 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.
• 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

Example 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

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

Example 3

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

abort() is defined as:

public func abort() -> Never 

Void

These examples would not have been possible with it returning 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:

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.

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