The way to use the end result sort to deal with errors in Swift 5?

Error dealing with fundamentals in Swift

The best way of dealing with errors modified rather a lot because the first model of Swift. The primary large milestone occurred in Swift 2, the place Apple fully revamped error administration. These days you should use the do, attempt, catch, throw, throws, rethrows key phrases as an alternative of coping with nasty NSError pointers, so this was a warmly welcomed addition for the language. Now in Swift 5 we take one other big leap ahead by introducing the End result sort as a built-in generic. First, let me present you all the very best practices of error dealing with within the Swift programming lanugage, subsequent I am going to present you some cool stuff by utilizing outcomes to cope with errors. 🚧

Optionals as error indicators

For easy situations you may at all times use non-compulsory values, to point that one thing unhealthy occurred. Additionally the guard assertion is extraordinarily useful for conditions like this.

let zeroValue = Int("0")! 
let nilValue = Int("not a quantity") 

guard let quantity = Int("6") else {
    fatalError("Ooops... this could at all times work, so we crash.")
}
print(quantity)

When you do not actually care in regards to the underlying sort of the error, this method is ok, however typically issues can get extra difficult, so that you would possibly want some particulars about the issue. Anyway, you may at all times cease the execution by calling the fatalError methodology, however in the event you accomplish that, nicely… your app will crash. 💥

There are additionally a pair different methods of cease execution course of, however this may very well be a subject of a standalone publish, so right here is only a fast cheat sheet of obtainable strategies:

precondition(false, "ouch")
preconditionFailure("ouch")
assert(false, "ouch")
assertionFailure("ouch")
fatalError("ouch")
exit(-1)

The important thing distinction between precondition and assertion is that assert will work solely in debug builds, however precondition is evaluated at all times (even in launch builds). Each strategies will set off a deadly error if the situation fails aka. is fake. ⚠️

Throwing errors by utilizing the Error protocol

You may outline your personal error varieties by merely confirming to the built-in Error protocol. Often most builders use an enum in an effort to outline totally different causes. It’s also possible to have a customized error message in the event you conform to the LocalizedError protocol. Now you are able to throw customized errors, simply use the throw key phrase if you would like to boost an error of your sort, however in the event you accomplish that in a operate, it’s a must to mark that operate as a throwing operate with the throws key phrases. 🤮

enum DivisionError: Error {
    case zeroDivisor
}

extension DivisionError: LocalizedError {
    public var errorDescription: String? {
        change self {
        case .zeroDivisor:
            return "Division by zero is sort of problematic. " +
                   "(https://en.wikipedia.org/wiki/Division_by_zero)"
        }
    }
}

func divide(_ x: Int, by y: Int) throws -> Int {
    guard y != 0 else {
        throw DivisionError.zeroDivisor
    }
    return x / y
}

Nice, so the divide operate above can generate a customized error message. If the divisor is zero it will throw the zeroDivision error case. Now think about the next state of affairs: you are attempting to learn the contents of a file from the disk. There may very well be a number of varieties of errors associated to permission or file existence, and so forth.

Rethrowing Features and Strategies A operate or methodology could be declared with the rethrows key phrase to point that it throws an error provided that one in every of it’s operate parameters throws an error. These features and strategies are often called rethrowing features and rethrowing strategies. Rethrowing features and strategies will need to have at the very least one throwing operate parameter.

Okay, so a throwing operate can emit totally different error varieties, additionally it will probably propagate all of the parameter errors, however how can we deal with (or ought to I say: catch) these errors?

The do-try-catch syntax

You simply merely should attempt to execute do a throwing operate. So do not belief the grasp, there’s undoubtedly room for making an attempt out issues! Unhealthy joke, proper? 😅

do {
    let quantity = attempt divide(10, by: 0)
    print(quantity)
}
catch let error as DivisionError {
    print("Division error handler block")
    print(error.localizedDescription)
}
catch {
    print("Generic error handler block")
    print(error.localizedDescription)
}

As you may see the syntax is fairly easy, you could have a do block, the place you may attempt to execute your throwing features, if one thing goes improper, you may deal with the errors in several catch blocks. By default an error property is obtainable inside each catch block, so you do not have to outline one your self by hand. You may nevertheless have catch blocks for particular error varieties by casting them utilizing the let error as MyType sytnax proper subsequent to the catch key phrase. So at all times attempt first, do not simply do! 🤪

Variations between attempt, attempt? and take a look at!

As we have seen earlier than you may merely attempt to name a operate that throws an error inside a do-catch block. If the operate triggers some sort of error, you may put your error dealing with logic contained in the catch block. That is quite simple & simple.

Generally in the event you do not actually care in regards to the underlying error, you may merely convert your throwing operate end result into an non-compulsory by utilizing attempt?. With this method you will get a zero end result if one thing unhealthy occurs, in any other case you will get again your common worth as it’s anticipated. Right here is the instance from above by utilizing attempt?:

guard let quantity = attempt? divide(10, by: 2) else {
    fatalError("This could work!")
}
print(quantity) 

One other approach is to forestall error propagation by utilizing attempt!, however it’s a must to be extraordinarily cautious with this method, as a result of if the execution of the “tried operate” fails, your software will merely crash. So use provided that you are completely certain that the operate will not throw an error. ⚠️

let quantity = attempt! divide(10, by: 2) 
print(quantity)

There are a couple of locations the place it is accepted to make use of drive attempt, however in many of the circumstances you need to go on an alternate path with correct error handlers.

In Swift 5 nested non-compulsory attempt? values are going to be flattened to a single non-compulsory worth. SE-0230 is an already carried out proposal that may break some present Swift code. Paul Hundson has a fast article about this habits.

Swift errors should not exceptions

The Swift compiler at all times requires you to catch all thrown errors, so a scenario of unhandled error won’t ever happen. I am not speaking about empty catch blocks, however unhandled throwing features, so you may’t attempt with out the do-catch companions. That is one key distinction when evaluating to exceptions. Additionally when an error is raised, the execution will simply exit the present scope. Exceptions will often unwind the stack, that may result in reminiscence leaks, however that is not the case with Swift errors. 👍

Introducing the end result sort

Swift 5 introduces a long-awaited generic end result sort. Because of this error dealing with could be much more easy, with out including your personal end result implementation. Let me present you our earlier divide operate by utilizing End result.

func divide(_ x: Int, by y: Int) -> End result<Int, DivisionError> {
    guard y != 0 else {
        return .failure(.zeroDivisor)
    }
    return .success(x / y)
}

let end result = divide(10, by: 2)
change end result {
case .success(let quantity):
    print(quantity)
case .failure(let error):
    print(error.localizedDescription)
}

The end result sort in Swift is principally a generic enum with a .success and a .failure case. You may go a generic worth in case your name succeeds or an Error if it fails.

One main benefit right here is that the error given again by result’s sort protected. Throwing features can throw any sort of errors, however right here you may see from the implementation {that a} DivisionError is coming again if one thing unhealthy occurs. One other profit is that you should use exhaustive change blocks to “iterate by way of” all of the doable error circumstances, even and not using a default case. So the compiler can maintain you protected, eg. if you’ll introduce a brand new error sort inside your enum declaration.

So by utilizing the End result sort it is clear that we’re getting again both end result information or a strongly typed error. It isn’t doable to get each or neither of them, however is that this higher than utilizing throwing features? Properly, let’s get asynchrounous!

func divide(_ x: Int, by y: Int, completion: ((() throws -> Int) -> Void)) {
    guard y != 0 else {
        completion { throw DivisionError.zeroDivisor }
        return
    }
    completion { return x / y }
}

divide(10, by: 0) { calculate in
    do {
        let quantity = attempt calculate()
        print(quantity)
    }
    catch {
        print(error.localizedDescription)
    }
}

Oh, my pricey… an inside closure! A completion handler that accepts a throwing operate, so we are able to propagate the error thrown to the outer hander? I am out! 🤬

Another choice is that we remove the throwing error fully and use an non-compulsory consequently, however on this case we’re again to sq. one. No underlying error sort.

func divide(_ x: Int, by y: Int, completion: (Int?) -> Void) {
    guard y != 0 else {
        return completion(nil)
    }
    completion(x / y)
}

divide(10, by: 0) { end result in
    guard let quantity = end result else {
        fatalError("nil")
    }
    print(quantity)
}

Lastly we’re getting someplace right here, however this time let’s add our error as a closure parameter as nicely. It is best to notice that each parameters should be optionals.

func divide(_ x: Int, by y: Int, completion: (Int?, Error?) -> Void) {
    guard y != 0 else {
        return completion(nil, DivisionError.zeroDivisor)
    }
    completion(x / y, nil)
}

divide(10, by: 0) { end result, error in
    guard error == nil else {
        fatalError(error!.localizedDescription)
    }
    guard let quantity = end result else {
        fatalError("Empty end result.")
    }
    print(quantity)
}

Lastly let’s introduce end result, so we are able to remove optionals from our earlier code.

func divide(_ x: Int, by y: Int, completion: (End result<Int, DivisionError>) -> Void) {
    guard y != 0 else {
        return completion(.failure(.zeroDivisor))
    }
    completion(.success(x / y))
}

divide(10, by: 0) { end result in
    change end result {
    case .success(let quantity):
        print(quantity)
    case .failure(let error):
        print(error.localizedDescription)
    }
}

See? Strongly typed errors, with out optionals. Dealing with errors in asynchronous operate is manner higher by utilizing the End result sort. When you contemplate that many of the apps are doing a little sort of networking, and the result’s often a JSON response, there you have already got to work with optionals (response, information, error) plus you could have a throwing JSONDecoder methodology… cannot wait the brand new APIs! ❤️

Working with the End result sort in Swift 5

We already know that the end result sort is principally an enum with a generic .succes(T) and a .failure(Error) circumstances, however there’s extra that I might like to indicate you right here. For instance you may create a end result sort with a throwing operate like this:

let end result = End result {
    return attempt divide(10, by: 2)
}

It is usually doable to transform again the end result worth by invoking the get operate.

do {
    let quantity = attempt end result.get()
    print(quantity)
}
catch {
    print(error.localizedDescription)
}

Additionally there are map, flatMap for remodeling success values plus it’s also possible to use the mapError or flatMapError strategies if you would like to remodel failures. 😎

let end result = divide(10, by: 2) 
let mapSuccess = end result.map { divide($0, by: 2) } 
let flatMapSuccess = end result.flatMap { divide($0, by: 2) } 
let mapFailure = end result.mapError { NSError(area: $0.localizedDescription, code: 0, userInfo: nil) }
let flatMapFailure = end result.flatMapError { .failure(NSError(area: $0.localizedDescription, code: 0, userInfo: nil)) }

That is it in regards to the End result sort in Swift 5. As you may see it is extraordinarily highly effective to have a generic implementation constructed immediately into the language. Now that we’ve end result, I simply want for greater kinded varieties or an async / await implementation. 👍