The Swift standard library’s Result type might just be a simple enum with cases for modeling an operation’s success or failure, but it also comes with several really useful convenience APIs built-in.

For example, it has a closure-based initializer, which we can use to easily convert any expression that throws into a Result value:

let data: Data = ...
let decoder = JSONDecoder()

// This will create a Result<Model, Error> instance, which will contain
// 'success' if its expression succeeded, and 'failure' if it ended
// up throwing an error:
let result = Result {
    try decoder.decode(Model.self, from: data)
}

// The above API is really useful when we want to return a Result
// value from an asynchronous operation, for example by calling
// a completion handler:
completionHandler(result)

Above we’re converting a raw Data value into a decoded Result, but we can also do the opposite — and extract a Data value from a Result instance, which we’ll then decode:

func decode(_ result: Result<Data, Error>) throws -> Model {
    // Using Result's 'get' method, we can either extract its
    // underlying value, or throw any error that it contains:
    let data = try result.get()
    let decoder = JSONDecoder()
    return try decoder.decode(Model.self, from: data)
}

Finally, Result also ships with a series of really useful mapping functions, for example map — which enables us to convert any result’s value into a new type, without having to do any error handling as part of such an operation:

let dataResult: Result<Data, Error> = ...

let stringResult = dataResult.map {
    String(decoding: $0, as: UTF8.self)
}

Support Swift by Sundell by checking out this sponsor:

Emerge: Continuously monitor and reduce your app’s size. Emerge’s easy to use plugins for GitHub and fastlane will automatically scan your app’s binary and provide you with simple, actionable suggestions on how to make it smaller and, in turn, faster for your users to download. Set up a demo now!