Introduction to async/await in Swift

The primary undertaking

Swift 5.5 accommodates plenty 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 jot down async code, however looks as if the way forward for Swift includes a local method to deal with concurrent duties even higher. There’s mix as properly, however that is solely obtainable for Apple platforms, so yeah… 🥲

Let me present you easy methods to convert your outdated callback & end result kind primarily based Swift code right into a shiny new async/await supported API. First we’re going to create our experimental async SPM undertaking.

import PackageDescription

let bundle = 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 may need observed that we’re utilizing the most recent swift-tools-version:5.4 and we added a couple of unsafe flags for this undertaking. It’s because we will use the brand new @most important attribute contained in the executable bundle goal, and the concurrency API requires the experimental flag to be current.

Now we must always create a most important entry level inside our most important.swift file. Since we’re utilizing the @most important attribute it’s potential to create a brand new struct with a static most important technique that may be routinely launched whenever you construct & run your undertaking utilizing Xcode or the command line. 🚀

@most important
struct MyProgram {

    static func most important() {
        print("Howdy, world!")
    }
}

Now that now we have a clear most important entry level, we must always add some commonplace URLSession associated performance that we’re going to exchange with new async/await calls as we refactor the code.

We’re going name our standard pattern todo service and validate our HTTP response. To get extra particular particulars of a potential 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 end result kind 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 (Consequence<[Todo], Error>) -> Void) {
    let req = URLRequest(url: URL(string: "https://jsonplaceholder.typicode.com/todos")!)
    let process = URLSession.shared.dataTask(with: req) { information, 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 information = information else {
            return completion(.failure(HTTP.Error.missingData))
        }
        do {
            let decoder = JSONDecoder()
            let todos = strive decoder.decode([Todo].self, from: information)
            return completion(.success(todos))
        }
        catch {
            return completion(.failure(error))
        }
    }
    process.resume()
}

@most important
struct MyProgram {

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

If you happen to keep in mind I already confirmed you the Mix model of this URLSession information process 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 will we convert our current code into an async variant? Properly, the excellent news is that there’s a technique referred to as withUnsafeContinuation that you should use to wrap current completion block primarily based calls to supply async variations of your features. The short and soiled resolution is that this:

import Basis

 

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

@most important
struct MyProgram {

    static func most important() async {
        let end result = await getTodos()
        swap end result {
        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 perform provides us a block that we are able to use to renew with the generic async return kind, this fashion it’s ridiculously simple to quickly write an async model of an current the callback primarily based perform. As at all times, the Swift developer staff did an excellent job right here. 👍

One factor you may need observed, that as a substitute of calling the dispatchMain() perform we have modified the principle perform into an async perform. Properly, the factor is that you could’t merely name an async perform inside a non-async (synchronous) technique. ⚠️

Interacting with sync code

With a purpose to name an async technique inside a sync technique, you need to use the brand new Process.indifferent perform and you continue to have to attend for the async features to finish utilizing the dispatch APIs.

import Basis



@most important
struct MyProgram {

    static func most important() {
        Process.indifferent {
            let end result = await getTodos()
            swap end result {
            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 technique inside an async perform, so there are not any restrictions there. Let me present you yet one more instance, this time we will 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 will calculate some numbers asynchronously and we would 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.most important.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.most important.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.most important.asyncAfter(deadline: .now() + 3) {
            print("Third quantity is now prepared.")
            c.resume(returning: 69)
        }
    }
}

@most important
struct MyProgram {

    static func most important() 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 would not matter for those who change the principle queue into a special concurrent queue, the async process 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 potential 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 fireplace the async duties instantly by way of the async let expressions. This new function is a part of the structured concurrency proposal.

@most important
struct MyProgram {

    static func most important() 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 approach on the principle queue, however you’ve got received the concept what I am making an attempt to indicate you right here, proper? 😅

Anyway, merely including the async/await function right into a programming language will not resolve the extra advanced points that now we have to cope with. Luckily Swift may have nice assist to async process administration and concurrent code execution. I am unable to wait to jot down extra about these new options. See you subsequent time, there’s a lot to cowl, I hope you may discover my async Swift tutorials helpful. 👋