Designing APIs with typed throws in Swift – Donny Wals

When Swift 2.0 added the throws key phrase to the language, people had been considerably divided on its usefulness. Some folks most popular designing their APIs with an (on the time) unofficial implementation of the Consequence kind as a result of that labored with each common and callback based mostly features.

Nevertheless, the language characteristic acquired adopted and a brand new criticism got here up repeatedly. The best way throws in Swift was designed didn’t permit builders to specify the varieties of errors {that a} operate might throw.

In each do {} catch {} block we write we’ve got to imagine and account for any object that conforms to the Error protocol to be thrown.

This submit will take a better take a look at how we will write catch blocks to deal with particular errors, and the way we will leverage the model new varieties throws that will likely be applied by SE-0413 just lately.

Let’s dig in!

The scenario right this moment: catching particular errors in Swift

The next code reveals a typical do { } catch { } block in Swift that you simply would possibly already be acquainted with:

do {
  strive loadfeed()
} catch {
  print(error.localizedDescription)
}

Calling a way that may throw errors ought to all the time be achieved in a do { } catch { } block except you name your technique with a strive? or a strive! prefix which is able to trigger you to disregard any errors that come up.

With the intention to deal with the error in your catch block, you’ll be able to solid the error that you simply’ve acquired to differing kinds as follows:

do {
  strive loadFeed()
} catch {
  change error {
  case let authError as AuthError:
    print("auth error", authError)
    // current login display
  case let networkError as NetworkError:
    print("community error", networkError)
    // current alert explaining what went improper
  default:
    print("error", error)
    // current generic alert with a message
  }
}

By casing your error within the change assertion, you’ll be able to have totally different code paths for various error varieties. This lets you extract info from the error as wanted. For instance, an authentication error might need some particular circumstances that you simply’d need to examine to accurately handle what went improper.

Right here’s what the case for AuthError would possibly find yourself wanting like:

case let authError as AuthError:
  print("auth error", authError)

  change authError {
  case .missingToken:
      print("lacking token")
      // current a login display
  case .tokenExpired:
    print("token expired")
    // try a token refresh
  }

When your API can return many alternative sorts of errors you’ll be able to find yourself with a number of totally different circumstances in your change, and with a number of ranges of nesting. This doesn’t look fairly and by chance we will work round this by defining catch blocks for particular error varieties.

For instance, right here’s what the identical management movement as earlier than seems like with out the change utilizing typed catch blocks:

do {
  strive loadFeed()
} 
catch let authError as AuthError {
  print("auth error", authError)

  change authError {
  case .missingToken:
      print("lacking token")
      // current a login display
  case .tokenExpired:
    print("token expired")
    // try a token refresh
  }
} 
catch let networkError as NetworkError {
  print("community error", networkError)
  // current alert explaining what went improper
} 
catch {
  print("error", error)
}

Discover how we’ve got a devoted catch for every error kind. This makes our code a little bit bit simpler to learn as a result of there’s quite a bit much less nesting.

The principle points with out code at this level are:

1. We don’t know which errors loadFeed can throw. If our API adjustments and we add extra error varieties, or even when we take away error varieties, the compiler gained’t have the ability to inform us. Which means we would have catch blocks for errors that may by no means get thrown or that we miss catch blocks for sure error varieties which suggests these errors get handles by the generic catch block.
2. We all the time want a generic catch on the finish even when we all know that we deal with all error varieties that our operate chilly most likely throw. It’s not an enormous downside, nevertheless it feels a bit like having an exhaustive change with a default case that solely incorporates a break assertion.

Fortunately, Swift proposal SE-0413 will repair these two ache factors by introducing typed throws.

Exploring typed throws

On the time of scripting this submit SE-0413 has been accepted however not but applied. Which means I’m basing this part on the proposal itself which signifies that I haven’t but had an opportunity to totally take a look at all code proven.

At its core, typed throws in Swift will permit us to tell callers of throwing features which errors they could obtain on account of calling a operate. At this level it seems like we’ll have the ability to solely throw a single kind of error from our operate.

For instance, we might write the next:

func loadFeed() throws(FeedError) {
  // implementation
}

What we can’t do is the next:

func loadFeed() throws(AuthError, NetworkError) {
  // implementation
}

So despite the fact that our loadFeed operate can throw a few errors, we’ll must design our code in a means that enables loadFeed to throw a single, particular kind as an alternative of a number of. We might outline our FeedError as follows to do that:

enum FeedError {
  case authError(AuthError)
  case networkError(NetworkError)
  case different(any Error)
}

By including the different case we will acquire a number of flexibility. Nevertheless, that additionally comes with the downsides that had been described within the earlier part so a greater design may very well be:

enum FeedError {
  case authError(AuthError)
  case networkError(NetworkError)
}

This totally relies on your wants and expectations. Each approaches can work nicely and the ensuing code that you simply write to deal with your errors will be a lot nicer when you’ve got much more management over the sorts of errors that you simply is likely to be throwing.

So after we name loadFeed now, we will write the next code:

do {
  strive loadFeed()
} 
catch {
  change error {
    case .authError(let authError):
      // deal with auth error
    case .networkError(let networkError):
      // deal with community error
  }
}

The error that’s handed to our catch is now a FeedError which signifies that we will change over the error and evaluate its circumstances immediately.

For this particular instance, we nonetheless require nesting to examine the precise errors that had been thrown however I’m certain you’ll be able to see how there are advantages to realizing which kind of errors we might obtain.

Within the circumstances the place you name a number of throwing strategies, we’re again to the quaint any Error in our catch:

do {
  let feed = strive loadFeed()
  strive cacheFeed(feed)
} catch {
  // error is any Error right here
}

Should you’re not acquainted with any in Swift, take a look at this submit to be taught extra.

The explanation we’re again to any Error right here is that our two totally different strategies won’t throw the identical error varieties which signifies that the compiler must drop all the way down to any Error since we all know that each strategies must throw one thing that conforms to Error.

In Abstract

Typed throws have been in excessive demand ever since Swift gained the throws key phrase. Now that we’re lastly about to get them, I feel a number of people are fairly comfortable.

Personally, I feel typed throws are a pleasant characteristic however that we gained’t see them used that a lot.

The truth that we will solely throw a single kind mixed with having to strive calls in a do block erasing our error again to any Error signifies that we’ll nonetheless be doing a bunch of switching and inspecting to see which error was thrown precisely, and the way we should always deal with that thrown error.

I’m certain typed throws will evolve sooner or later however for now I don’t suppose I’ll be leaping on them immediately as soon as they’re launched.