Designing APIs with typed throws in Swift – Donny Wals

When Swift 2.0 added the throws key phrase to the language, of us have been considerably divided on its usefulness. Some folks most popular designing their APIs with an (on the time) unofficial implementation of the End result sort as a result of that labored with each common and callback primarily based capabilities.

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

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

This put up 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 shall be carried out via SE-0413 lately.

Let’s dig in!

The state of affairs in the present day: catching particular errors in Swift

The next code reveals an ordinary do { } catch { } block in Swift that you just would possibly already be aware of:

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

Calling a technique that may throw errors ought to all the time be accomplished in a do { } catch { } block until you name your methodology with a attempt? or a attempt! prefix which can trigger you to disregard any errors that come up.

To be able to deal with the error in your catch block, you possibly can forged the error that you just’ve acquired to differing types as follows:

do {
  attempt loadFeed()
} catch {
  change error {
  case let authError as AuthError:
    print("auth error", authError)
    // current login display screen
  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 possibly can have totally different code paths for various error varieties. This lets you extract data from the error as wanted. For instance, an authentication error may need some particular circumstances that you just’d need to examine to accurately handle what went improper.

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

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

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

When your API can return many alternative sorts of errors you possibly can 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 fortuitously 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 appears like with out the change utilizing typed catch blocks:

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

  change authError {
  case .missingToken:
      print("lacking token")
      // current a login display screen
  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 now we have a devoted catch for every error sort. This makes our code a bit bit simpler to learn as a result of there’s so much 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 received’t have the ability to inform us. Because of this we’d have catch blocks for errors that may by no means get thrown or that we miss catch blocks for sure error varieties which implies 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, however it feels a bit like having an exhaustive change with a default case that solely accommodates 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 penning this put up SE-0413 has been accepted however not but carried out. Because of this I’m basing this part on the proposal itself which signifies that I haven’t but had an opportunity to totally check all code proven.

At its core, typed throws in Swift will permit us to tell callers of throwing capabilities which errors they may obtain because of calling a operate. At this level it appears like we’ll have the ability to solely throw a single sort 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 although our loadFeed operate can throw a few errors, we’ll must design our code in a method that enables loadFeed to throw a single, particular sort 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 achieve a number of flexibility. Nonetheless, that additionally comes with the downsides that have been described within the earlier part so a greater design could possibly be:

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

This totally is determined by your wants and expectations. Each approaches can work nicely and the ensuing code that you just write to deal with your errors might be a lot nicer when you may have much more management over the sorts of errors that you just is perhaps throwing.

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

do {
  attempt 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 straight.

For this particular instance, we nonetheless require nesting to examine the precise errors that have been thrown however I’m certain you possibly can see how there are advantages to understanding which sort 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 = attempt loadFeed()
  attempt cacheFeed(feed)
} catch {
  // error is any Error right here
}

In case you’re not aware of any in Swift, try this put up to be taught extra.

The rationale we’re again to any Error right here is that our two totally different strategies may not 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 should 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 believe a number of of us are fairly completely satisfied.

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

The truth that we will solely throw a single sort mixed with having to attempt 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 must always deal with that thrown error.

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