What's difference between `add(_)` and `add(_) async`?

Question

I don't understand what's the difference between add(_) and add(_) async method. Like the below code, the MyActor has two add methods and one of them uses async keyword. They can exist at the same time. If I comment out the second add method it will output AAAA. If both add methods exist at the same time, output "BBBBB"。

actor MyActor {
    var num: Int = 0
    func add(_ value: Int) {
        print("AAAAA")
        num += value
    }
    
    func add(_ value: Int) async {
        print("BBBBB")
        num += value
    }
}


let actor = MyActor()
Task {
    await actor.add(200)
    print(await actor.num)
}

Supplementary:

With the second add method commented out, I defined let actor = MyActor() outside Task and I noticed the add method signed as add(_:). If move let actor = MyActor() inside Task the add method signed as add(_:) async

Answer 1

The difference emerges inside the actor, for example

actor MyActor {
    func addSync(_ value: Int) {

    }

    func addAsync(_ value: Int) async {

    }

    func f() {
        addSync(0)
    }

    func g() async {
        addSync(0)
        await addAsync(0)
    }
}

In the actor method f and g you can call addSync synchronously. While outside the actor, you need always call an actor method with the await keyword as if the method is asynchronous:

func outside() async {
    let actor = MyActor()
    await actor.addSync(0)
}

Answer 2

Async in Swift allows for structured concurrency, which will improve the readability of complex asynchronous code. Completion closures are no longer needed, and calling into multiple asynchronous methods after each other is a lot more readable.

Async stands for asynchronous and can be seen as a method attribute making it clear that a method performs asynchronous work. An example of such a method looks as follows:

func fetchImages() async throws -> [UIImage] {
// .. perform data request
 }

The fetchImages method is defined as async throwing, which means that it’s performing a failable asynchronous job. The method would return a collection of images if everything went well or throws an error if something went wrong.

How async replaces closure completion callbacks Async methods replace the often seen closure completion callbacks. Completion callbacks were common in Swift to return from an asynchronous task, often combined with a Result type parameter. The above method would have been written as followed:

func fetchImages(completion: (Result<[UIImage], Error>) -> Void) {
// .. perform data request
 }

Defining a method using a completion closure is still possible in Swift today, but it has a few downsides that are solved by using async instead:

You have to make sure yourself to call the completion closure in each possible method exit. Not doing so will possibly result in an app waiting for a result endlessly. Closures are harder to read. It’s not as easy to reason about the order of execution as compared to how easy it is with structured concurrency. Retain cycles need to be avoided using weak references. Implementors need to switch over the result to get the outcome. It’s not possible to use try catch statements from the implementation level. These downsides are based on the closure version using the relatively new Result enum. It’s likely that a lot of projects still make use of completion callbacks without this enumeration:

func fetchImages(completion: ([UIImage]?, Error?) -> Void) {
// .. perform data request
}

Defining a method like this makes it even harder to reason about the outcome on the caller’s side. Both value and error are optional, which requires us to perform an unwrap in any case. Unwrapping these optionals results in more code clutter which does not help to improve readability.