在平面图中使用 Swift Task 进行异步/等待

Question

I'm trying to receive an async function return value inside a flatMap and wrap it under a Task to allow for async functionality but I'm having this error when I'm trying to access the Task value:

'async' property access in a function that does not support concurrency

How do I go about returning the value?

Playground

import UIKit

public func isEvenNumber(num:(Int)) async -> Result<Int, Error> {
    if num%2 == 0 {
        print("EVEN")
        return .success(1)
    }
    print("ODD")
    return .success(0)
}

func profileAsyncFunc() async -> Result<Bool, Error> {
    return await isEvenNumber(num: 3)
        .flatMap{ _ -> Result<Bool,Error> in
            
            Task {
                return await testAsyncFunc()
            }.value
         }
}

func testAsyncFunc() async -> Result<Bool, Error> {
    let basicTask = Task { () -> Result<Bool, Error> in
        .success(true)
    }
    return await basicTask.value
}

Task {
    await profileAsyncFunc()
}

Answer 1

A few observations:

1. Swift concurrency simplifies this quite a bit. No flatMap is needed.

2. The isEvenNumber is not really asynchronous unless you await something. Adding async qualifier does not make it asynchronous. It only means that you could add some asynchronous code in the function, but only if you await something within the function.

3. In Swift concurrency, the Result type is no longer needed and quickly becomes syntactic noise. In an async function, you simply either return a value, or throw an error.

---

Let us assume that isEvenNumber is just a placeholder for something sufficiently complicated that you did need to make it asynchronous to avoid blocking the current actor. Furthermore, while you do not throw errors, let us assume that this is a proxy for some method that would.

If all of that were the case, you would need to make sure that you get it off the current actor with a detached task, and then it would be asynchronous, as you would await its value . And I am arbitrarily defining isEven to throw an error if the value is negative. (Clearly, this is not a reasonable reason to throw an error, but included it for illustrative purposes.)

Thus:

enum NumberError: Error {
    case negative
}

// This is not sufficiently computationally intensive to warrant making it run
// asynchronously, but let us assume that it was. You would do something like:

func isEven(_ num: Int) async throws -> Bool {
    if num < 0 { throw NumberError.negative }

    return await Task.detached {
        num.isMultiple(of: 2)
    }.value
}

func profileAsyncFunc() async throws -> Bool {
    try await isEven(3)
}

Then you could do:

Task {
    let isEven = try await profileAsyncFunc()
    print(isEven)
}

---

You said:

I'm trying to receive an async function return value inside a flatMap …

Why? You do not need flatMap in Swift concurrency, as you might use in Combine.

If you are simply trying to adopt async - await , you can just excise this from your code. If there is some other problem that you are trying to solve by introducing flatMap , please edit the question providing a more complete example, and explain the intended rationale for flatMap .

As it stands, the example is sufficiently oversimplified that it makes it hard for us to understand the problem you are really trying to solve.