Introduction to async/await in Swift

The primary challenge

Swift 5.5 accommodates a number of new options, most of them is all about “a greater concurrency mannequin” for the language. The very first step into this new asynchronous world is a correct async/await system.

In fact you possibly can nonetheless use common completion blocks or the Dispatch framework to write down async code, however looks like the way forward for Swift includes a local strategy to deal with concurrent duties even higher. There may be mix as effectively, however that is solely obtainable for Apple platforms, so yeah… ?

Let me present you how one can convert your previous callback & outcome sort based mostly Swift code right into a shiny new async/await supported API. First we’re going to create our experimental async SPM challenge.

import PackageDescription

let package deal = Package deal(
    title: "AsyncSwift",
    merchandise: [
        .executable(name: "AsyncSwift", targets: ["AsyncSwift"])
    ],
    dependencies: [
        
    ],
    targets: [
        .executableTarget(name: "AsyncSwift",
                          swiftSettings: [
                            .unsafeFlags([
                                "-parse-as-library",
                                "-Xfrontend", "-disable-availability-checking",
                                "-Xfrontend", "-enable-experimental-concurrency",
                            ])
                          ]
        ),
        .testTarget(title: "AsyncSwiftTests", dependencies: ["AsyncSwift"]),
    ]
)

You might need observed that we’re utilizing the newest swift-tools-version:5.4 and we added a couple of unsafe flags for this challenge. It’s because we’ll use the brand new @predominant attribute contained in the executable package deal goal, and the concurrency API requires the experimental flag to be current.

Now we should always create a predominant entry level inside our predominant.swift file. Since we’re utilizing the @predominant attribute it’s doable to create a brand new struct with a static predominant methodology that may be mechanically launched whenever you construct & run your challenge utilizing Xcode or the command line. ?

@predominant
struct MyProgram {

    static func predominant() {
        print("Good day, world!")
    }
}

Now that now we have a clear predominant entry level, we should always add some customary URLSession associated performance that we’re going to substitute with new async/await calls as we refactor the code.

We’re going name our typical pattern todo service and validate our HTTP response. To get extra particular particulars of a doable error, we are able to use a easy HTTP.Error object, and naturally as a result of the dataTask API returns instantly now we have to make use of the dispatchMain() name to attend for the asynchronous HTTP name. Lastly we merely swap the outcome sort and exit if wanted. ?

import Basis

enum HTTP {
    enum Error: LocalizedError {
        case invalidResponse
        case badStatusCode
        case missingData
    }
}

struct Todo: Codable {
    let id: Int
    let title: String
    let accomplished: Bool
    let userId: Int
}

func getTodos(completion: @escaping (End result<[Todo], Error>) -> Void) {
    let req = URLRequest(url: URL(string: "https://jsonplaceholder.typicode.com/todos")!)
    let activity = URLSession.shared.dataTask(with: req) { knowledge, response, error in
        guard error == nil else  {
            return completion(.failure(error!))
        }
        guard let response = response as? HTTPURLResponse else {
            return completion(.failure(HTTP.Error.invalidResponse))
        }
        guard 200...299 ~= response.statusCode else {
            return completion(.failure(HTTP.Error.badStatusCode))
        }
        guard let knowledge = knowledge else {
            return completion(.failure(HTTP.Error.missingData))
        }
        do {
            let decoder = JSONDecoder()
            let todos = strive decoder.decode([Todo].self, from: knowledge)
            return completion(.success(todos))
        }
        catch {
            return completion(.failure(error))
        }
    }
    activity.resume()
}

@predominant
struct MyProgram {

    static func predominant() {
        getTodos { outcome in
            swap outcome {
            case .success(let todos):
                print(todos.rely)
                exit(EXIT_SUCCESS)
            case .failure(let error):
                fatalError(error.localizedDescription)
            }
            
        }
        dispatchMain()
    }
}

Should you bear in mind I already confirmed you the Mix model of this URLSession knowledge activity name some time again, however as I discussed this Mix isn’t solely obtainable for iOS, macOS, tvOS and watchOS.

Async/await and unsafe continuation

So how can we convert our present code into an async variant? Effectively, the excellent news is that there’s a methodology known as withUnsafeContinuation that you should utilize to wrap present completion block based mostly calls to provide async variations of your features. The fast and soiled resolution is that this:

import Basis

 

func getTodos() async -> End result<[Todo], Error> {
    await withUnsafeContinuation { c in
        getTodos { outcome in
            c.resume(returning: outcome)
        }
    }
}

@predominant
struct MyProgram {

    static func predominant() async {
        let outcome = await getTodos()
        swap outcome {
        case .success(let todos):
            print(todos.rely)
            exit(EXIT_SUCCESS)
        case .failure(let error):
            fatalError(error.localizedDescription)
        }
    }
}

The continuations proposal was born to supply us the mandatory API to work together with synchronous code. The withUnsafeContinuation operate provides us a block that we are able to use to renew with the generic async return sort, this fashion it’s ridiculously simple to quickly write an async model of an present the callback based mostly operate. As at all times, the Swift developer staff did a fantastic job right here. ?

One factor you might need observed, that as a substitute of calling the dispatchMain() operate we have modified the primary operate into an async operate. Effectively, the factor is which you could’t merely name an async operate inside a non-async (synchronous) methodology. ??

Interacting with sync code

In an effort to name an async methodology inside a sync methodology, it’s important to use the brand new Activity.indifferent operate and you continue to have to attend for the async features to finish utilizing the dispatch APIs.

import Basis



@predominant
struct MyProgram {

    static func predominant() {
        Activity.indifferent {
            let outcome = await getTodos()
            swap outcome {
            case .success(let todos):
                print(todos.rely)
                exit(EXIT_SUCCESS)
            case .failure(let error):
                fatalError(error.localizedDescription)
            }
        }
        dispatchMain()
    }
}

In fact you possibly can name any sync and async methodology inside an async operate, so there aren’t any restrictions there. Let me present you another instance, this time we’ll use the Grand Central Dispatch framework, return a couple of numbers and add them asynchronously.

Serial vs concurrent execution

Think about a typical use-case the place you would like to mix (pun meant) the output of some lengthy working async operations. In our instance we’ll calculate some numbers asynchronously and we might wish to sum the outcomes afterwards. Let’s study the next code…

import Basis

func calculateFirstNumber() async -> Int {
    print("First quantity is now being calculated...")
    return await withUnsafeContinuation { c in
        DispatchQueue.predominant.asyncAfter(deadline: .now() + 2) {
            print("First quantity is now prepared.")
            c.resume(returning: 42)
        }
    }
}

func calculateSecondNumber() async -> Int {
    print("Second quantity is now being calculated...")
    return await withUnsafeContinuation { c in
        DispatchQueue.predominant.asyncAfter(deadline: .now() + 1) {
            print("Second quantity is now prepared.")
            c.resume(returning: 6)
        }
    }
}

func calculateThirdNumber() async -> Int {
    print("Third quantity is now being calculated...")
    return await withUnsafeContinuation { c in
        DispatchQueue.predominant.asyncAfter(deadline: .now() + 3) {
            print("Third quantity is now prepared.")
            c.resume(returning: 69)
        }
    }
}

@predominant
struct MyProgram {

    static func predominant() async {
        let x = await calculateFirstNumber()
        let y = await calculateSecondNumber()
        let z = await calculateThirdNumber()
        print(x + y + z)
    
}

As you possibly can see these features are asynchronous, however they’re nonetheless executed one after one other. It actually does not matter if you happen to change the primary queue into a unique concurrent queue, the async activity itself isn’t going to fireplace till you name it with await. The execution order is at all times serial. ?

Spawn duties utilizing async let

It’s doable to alter this conduct through the use of the model new async let syntax. If we transfer the await key phrase only a bit down the road we are able to hearth the async duties straight away through the async let expressions. This new function is a part of the structured concurrency proposal.

@predominant
struct MyProgram {

    static func predominant() async {
        async let x = calculateFirstNumber()
        async let y = calculateSecondNumber()
        async let z = calculateThirdNumber()

        let res = await x + y + z
        print(res)
    }
}

Now the execution order is concurrent, the underlying calculation nonetheless occurs in a serial means on the primary queue, however you have acquired the thought what I am attempting to point out you right here, proper? ?

Anyway, merely including the async/await function right into a programming language will not remedy the extra advanced points that now we have to take care of. Fortuitously Swift may have nice help to async activity administration and concurrent code execution. I can not wait to write down extra about these new options. See you subsequent time, there’s a lot to cowl, I hope you will discover my async Swift tutorials helpful. ?