Async sequences (AsyncSequence) in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this async sequence code?

Consider the following Swift code using an async sequence. What will be printed when this code runs?

Swift

import Foundation

struct Countdown: AsyncSequence {
    typealias Element = Int
    let start: Int

    struct AsyncIterator: AsyncIteratorProtocol {
        var current: Int

        mutating func next() async -> Int? {
            if current < 0 {
                return nil
            } else {
                let value = current
                current -= 1
                return value
            }
        }
    }

    func makeAsyncIterator() -> AsyncIterator {
        AsyncIterator(current: start)
    }
}

@main
struct Main {
    static func main() async {
        let countdown = Countdown(start: 3)
        var result = ""
        for await number in countdown {
            result += "\(number) "
        }
        print(result.trimmingCharacters(in: .whitespaces))
    }
}

A "3 2 1 0 -1"

B "4 3 2 1 0"

C "0 1 2 3"

D "3 2 1 0"

💡 Hint

Think about how the iterator decreases the current value and when it stops.

The async iterator starts at 3 and decreases by 1 each time until it reaches -1, at which point it returns nil and stops. So the sequence yields 3, 2, 1, 0.

🧠 Conceptual

intermediate

Which statement about AsyncSequence is true?

Choose the correct statement about AsyncSequence in Swift.

A AsyncSequence allows iteration over values asynchronously using for await-in loops.

B AsyncSequence requires implementing a synchronous iterator method called makeIterator().

C AsyncSequence can only be used with arrays and dictionaries.

D AsyncSequence does not support throwing errors during iteration.

💡 Hint

Think about how async sequences are consumed in Swift.

AsyncSequence supports asynchronous iteration using for await-in loops. The iterator is asynchronous and returns values with async next() method.

🔧 Debug

advanced

What error does this async sequence code produce?

This Swift code attempts to create an async sequence but has a problem. What error will it cause?

Swift

struct Numbers: AsyncSequence {
    typealias Element = Int

    func makeAsyncIterator() -> some AsyncIteratorProtocol {
        return Iterator()
    }

    struct Iterator: AsyncIteratorProtocol {
        var current = 0

        mutating func next() async -> Int? {
            if current < 3 {
                defer { current += 1 }
                return current
            } else {
                return nil
            }
        }
    }
}

A Compile-time error: 'current' used in mutating context but 'next()' is not mutating

B Runtime error: Infinite loop due to never returning nil

C Compile-time error: Missing async keyword on makeAsyncIterator()

D No error, code runs correctly

💡 Hint

Check if the method that changes state is marked mutating.

The next() method tries to modify 'current' but is not marked mutating, causing a compile-time error.

📝 Syntax

advanced

Which option correctly defines an async iterator's next() method?

Select the correct syntax for the next() method in an AsyncIteratorProtocol conforming struct.

A mutating func next() -> Element? async { ... }

B func next() -> Element? async { ... }

C mutating func next() async -> Element? { ... }

D func next() async throws -> Element? { ... }

💡 Hint

Remember the order of async and throws keywords in Swift function declarations.

The correct syntax places async before the return arrow and mutating before func. Option C matches the required signature.

🚀 Application

expert

How many items does this async sequence produce?

Given this async sequence, how many elements will be produced when iterated fully?

Swift

struct EvenNumbers: AsyncSequence {
    typealias Element = Int
    let max: Int

    struct Iterator: AsyncIteratorProtocol {
        var current = 0
        let max: Int

        mutating func next() async -> Int? {
            if current > max {
                return nil
            }
            let result = current
            current += 2
            return result
        }
    }

    func makeAsyncIterator() -> Iterator {
        Iterator(current: 0, max: max)
    }
}

@main
struct Main {
    static func main() async {
        let evens = EvenNumbers(max: 7)
        var count = 0
        for await _ in evens {
            count += 1
        }
        print(count)
    }
}

A 5

B 4

C 7

D 3

💡 Hint

Count even numbers from 0 up to and including max.

The sequence yields 0, 2, 4, 6 before current becomes 8 which is > 7, so iteration stops after 4 elements.