Async queue to enqueue elements and consume them in an `AsyncSequence`.

AsyncQueue.swift

// MARK: - Queue

struct Queue<Element> {
    private var enqueueArray: [Element] = []
    private var dequeueArray: [Element] = []

    var isEmpty: Bool {
        enqueueArray.isEmpty && dequeueArray.isEmpty
    }
}

extension Queue {
    mutating func enqueue(_ element: Element) {
        enqueueArray.append(element)
    }

    mutating func dequeue() -> Element? {
        if dequeueArray.isEmpty {
            dequeueArray = enqueueArray.reversed()
            enqueueArray.removeAll()
        }
        return dequeueArray.popLast()
    }
}

extension Queue {
    mutating func removeAll() {
        enqueueArray.removeAll()
        dequeueArray.removeAll()
    }
}

// MARK: - AsyncQueue

actor AsyncQueue<Element> {
    private var queue = Queue<Element>()

    private var nextContinuation: CheckedContinuation<Element, Never>?

    nonisolated var elements: Elements { Elements(queue: self) }
}

extension AsyncQueue {
    func enqueue(_ element: Element) {
        if let nextContinuation {
            nextContinuation.resume(returning: element)
            self.nextContinuation = nil
        } else {
            queue.enqueue(element)
        }
    }
}

// MARK: - AsyncIteratorProtocol

extension AsyncQueue: AsyncIteratorProtocol {

    func next() async -> Element? {
        guard nextContinuation == nil else { return nil }

        if let next = queue.dequeue() {
            return next
        } else {
            return await withCheckedContinuation { nextContinuation = $0 }
        }
    }
}

// MARK: - Elements

extension AsyncQueue {

    struct Elements: AsyncSequence {

        typealias AsyncIterator = AsyncQueue

        let queue: AsyncQueue

        func makeAsyncIterator() -> AsyncQueue {
            queue
        }
    }
}

Article

Related article on Woody's Findings.

Usage example

let queue = AsyncQueue<String>()

Task {
    for await element in queue.elements {
        print(element)
        try await Task.sleep(for: .seconds(1))
    }
}

Task {
    await queue.enqueue("A")
    await queue.enqueue("B")
}