The principle mission

Swift 5.5 incorporates numerous 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.

After all you may 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 method to deal with concurrent duties even higher. There’s mix as nicely, however that is solely accessible for Apple platforms, so yeah… 🥲

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

import PackageDescription

let bundle = Package deal(
    identify: "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(identify: "AsyncSwiftTests", dependencies: ["AsyncSwift"]),
    ]
)

You might need seen that we’re utilizing the most recent swift-tools-version:5.4 and we added just a few unsafe flags for this mission. It’s because we will use the brand new @essential attribute contained in the executable bundle goal, and the concurrency API requires the experimental flag to be current.

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

@essential
struct MyProgram {

    static func essential() {
        print("Hi there, world!")
    }
}

Now that we have now a clear essential entry level, we must 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 ordinary pattern todo service and validate our HTTP response. To get extra particular particulars of a attainable error, we are able to use a easy HTTP.Error object, and naturally as a result of the dataTask API returns instantly we have now to make use of the dispatchMain() name to attend for the asynchronous HTTP name. Lastly we merely swap the end result 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 (Outcome<[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 = attempt decoder.decode([Todo].self, from: information)
            return completion(.success(todos))
        }
        catch {
            return completion(.failure(error))
        }
    }
    process.resume()
}

@essential
struct MyProgram {

    static func essential() {
        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()
    }
}

When you 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 just isn’t solely accessible for iOS, macOS, tvOS and watchOS.

Async/await and unsafe continuation

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

import Basis

 

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

@essential
struct MyProgram {

    static func essential() 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 offers us a block that we are able to use to renew with the generic async return sort, this manner it’s ridiculously simple to quickly write an async model of an current the callback based mostly perform. As all the time, the Swift developer crew did a terrific job right here. 👍

One factor you might need seen, that as a substitute of calling the dispatchMain() perform we have modified the primary perform into an async perform. Nicely, the factor is that you would be able to’t merely name an async perform inside a non-async (synchronous) technique. ⚠️

Interacting with sync code

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

import Basis



@essential
struct MyProgram {

    static func essential() {
        Activity.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()
    }
}

After all you may name any sync and async technique inside an async perform, so there are not any restrictions there. Let me present you yet another instance, this time we will use the Grand Central Dispatch framework, return just a few numbers and add them asynchronously.

Serial vs concurrent execution

Think about a standard 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 prefer 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.essential.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.essential.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.essential.asyncAfter(deadline: .now() + 3) {
            print("Third quantity is now prepared.")
            c.resume(returning: 69)
        }
    }
}

@essential
struct MyProgram {

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

As you may see these capabilities are asynchronous, however they’re nonetheless executed one after one other. It actually would not matter when you change the primary queue into a unique concurrent queue, the async process itself just isn’t going to fireside till you name it with await. The execution order is all the time serial. 🤔

Spawn duties utilizing async let

It’s attainable to alter this habits by utilizing 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 instantly by way of the async let expressions. This new characteristic is a part of the structured concurrency proposal.

@essential
struct MyProgram {

    static func essential() 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’ve got acquired the concept what I am making an attempt to point out you right here, proper? 😅

Anyway, merely including the async/await characteristic right into a programming language will not remedy the extra complicated points that we have now to cope with. Thankfully Swift may have nice help to async process 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 may discover my async Swift tutorials helpful. 👋