NEW: Master Swift design patterns with my latest book! >>

How to use the rethrows keyword

Written by Paul Hudson    @twostraws

The rethrows keyword is used when you write a function (let’s call it A) that accepts a throwing function as a parameter (let’s call it B). If function B throws errors, then the function A becomes a throwing function too, but if function B doesn’t throw errors then neither does function A.

First, here’s a simple function that accepts a username and always throws an error because biometric authentication isn’t available:

extension String: Error { }

func authenticateBiometrically(_ user: String) throws -> Bool {
    throw "Failed"

That little String extension allows us to throw strings as errors, which saves a little time.

Now here’s a second function that doesn’t throw:

func authenticateByPassword(_ user: String) -> Bool {
    return true

So, biometric authentication (Touch ID, Face ID) always throws an error, and password authentication always works.

Now we want to write an authentication function that can either run biometric authentication or password authentication depending on what its given. Because one of the two possibilities can throw, we mark its parameter as throwing, like this:

method: (String) throws -> Bool

What we’re saying is that this function might be able to throw, not that it must throw.

Try adding this function now:

func authenticateUser(method: (String) throws -> Bool) throws {
    try method("twostraws")

We can now call that function like this:

do {
    try authenticateUser(method: authenticateByPassword)
} catch {

Now for the important part: we both know that authenticateByPassword() doesn’t throw errors, and Swift can see that too, so if we change the definition of authenticateUser from throws to rethrows Swift will no longer require us to use do/catch when passing it a non-throwing parameter.

Change the function to this:

func authenticateUser(method: (String) throws -> Bool) rethrows {
    try method("twostraws")

Now Xcode will give you a warning: the catch block later on is unreachable because authenticateUser will never throw errors. But if you were to call it using authenticateBiometrically then you would need the do/catch blocks – Swift is able to evaluate the flow of our code much better, which means we need to write less code.

Available from iOS 8.0 – learn more in my book Pro Swift

Did this solution work for you? Please pass it on!

Other people are reading…

About the Swift Knowledge Base

This is part of the Swift Knowledge Base, a free, searchable collection of solutions for common iOS questions.

Help support Hacking with Swift

This site is funded by Hacking with Swift supporters who buy my e-books. If you can, please support my work – it comes packed with bonus material!

Click here to visit the Hacking with Swift store >>