Implementing a custom asynchronous sequence in Swift

Question

Imagine I want to create a function that, given an array of numbers, computes the square, cube, and fourth power of each number in an asynchronous fashion and returns a flattened, asynchronous sequence of all these results.

So, for example, for the input array [2, 3, 4], it should return an AsyncSequence instance yielding the elements [4, 8, 16, 9, 27, 81, 16, 64, 256].

Then let's say, instead of computing x^2, x^3, x^4, I would like it to compute x, x^2, x^3, ..., x^k where k is sort of a random integer that can be different for every x and is not known beforehand (its value comes to be known only as the powers are being computed). How would I implement such a pattern?

Basically it's kind of the same of creating your own type conforming to Sequence: you ought make it conform to AsyncSequence, hence it must provide an async iterator via makeAsyncIterator. In your case I think you could just use an AsyncStream internally for the async iterator since it won't throw any error. — valeCocoa, Jul 11 '22 at 16:42
The *As a next step* part is really a second question with a separate answer. Good SO questions should be focused on one thing -- consider removing that and posting it as its own question. — Caleb, Jul 11 '22 at 19:25
Do not edit a question include its own answer. If you can answer your own question, you are free to do so: as an Answer, in the Answer field. But you cannot do that now, because this question is closed. Do not edit the question purely as a way to work around the rules. Edit it solely to _improve the question._ — matt, Jul 12 '22 at 17:10

Rob · Answer 1 · 2022-07-12T17:07:20.713

An AsyncStream could do the job. E.g., given an array of integers, values, the asynchronous sequence would be:

let stream = AsyncStream<Int> { continuation in
    Task.detached {
        for value in values {
            var result = value
            for _ in 1 ..< n {
                result *= value
                continuation.yield(result)
            }
        }

        continuation.finish()
    }
}

But this calculation of x², x³, ..., xⁿ for each element in the input array might not be a good candidate for an asynchronous sequence. Each subsequent value can be calculated nearly instantaneously (just multiplying the previously emitted value by x) and, as such, should probably just be a standard, synchronous sequence.

Generally, asynchronous sequences should be those that are sufficiently slow to justify moving it into the background or otherwise has results that are emitted asynchronously over time.

FWIW, if your question was how to make your own AsyncSequence rather than just using AsyncStream, see [this example](https://stackoverflow.com/a/72408350/1271826). WWDC 2021 video [Meet AsyncSequence](https://developer.apple.com/videos/play/wwdc2021/10058/) is a good primer. — Rob, Jul 12 '22 at 05:18
Or [SE-0298 - Async/Await: Sequences](https://github.com/apple/swift-evolution/blob/main/proposals/0298-asyncsequence.md). — Rob, Jul 13 '22 at 04:08

score 0 · Accepted Answer · answered Jul 13 '22 at 16:42

Thanks a lot to Rob for providing the basic idea on how to implement something like this.

I wrote it in the following way:

func powers(of numbers: [Int]) -> AsyncStream<Int> {
    return AsyncStream<Int> { continuation in
        Task {
            for number in numbers {
                for await power in Powers(of: number) {
                    continuation.yield(power)
                }
            }
            continuation.finish()
        }
    }
}

struct Powers: AsyncSequence {
    init(of base: Int) {
        self.base = base
    }
    
    func makeAsyncIterator() -> PowersIterator {
        return PowersIterator(base: self.base)
    }
    
    let base: Int
    typealias Element = Int
}

struct PowersIterator: AsyncIteratorProtocol {
    mutating func next() async -> Int? {
        if !self.shouldFinish() {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            defer {
                self.exponent += 1
            }
            return power(self.base, self.exponent)
        } else {
            return nil
        }
    }
    
    private func shouldFinish() -> Bool {
        return Int.random(in: 1...10) == 1
    }
    
    private func power(_ base: Int, _ exponent: UInt) -> Int {
        return (0..<exponent).reduce(1) { power, _ in power * base }
    }
    
    var exponent = UInt(1)
    let base: Int
}

It can be invoked using this code:

Task {
    let numbers = [1, 2, 3, 4, 5]
    for await power in powers(of: numbers) {
        print(power, terminator: " ")
    }
}

Possible output:

1 1 1 2 4 8 16 32 64 3 9 27 4 16 64 256 5 25 125 625 3125 15625

The solution is a little more complex than it ought to be. But that's of course because I actually wanted to compute something that would really need to be computed asynchronously and has the same computational structure as this example. That is also the reason for why I created a separate async sequence for computing the powers.

If this helps anyone out, I'll be glad.

Implementing a custom asynchronous sequence in Swift

2 Answers2