Async sequences (AsyncSequence) in Swift - Mini Project: Build & Apply

Async sequences (AsyncSequence)

📖 Scenario: Imagine you want to receive messages one by one as they arrive, like getting text messages on your phone. You will use an async sequence to handle these messages smoothly without waiting for all of them at once.

🎯 Goal: Build a simple Swift program that creates an async sequence of messages, processes them one by one asynchronously, and prints each message as it arrives.

📋 What You'll Learn

Create an async sequence of strings representing messages

Create a configuration variable to limit how many messages to process

Use a for await loop to process messages asynchronously

Print each message as it is received

💡 Why This Matters

🌍 Real World

Async sequences are useful when you receive data over time, like messages, sensor readings, or user inputs, and want to handle each piece as it arrives without blocking your program.

💼 Career

Understanding async sequences helps you write efficient Swift code for apps that need to handle streaming data or perform background tasks smoothly, a common requirement in mobile and server-side development.

1

Create an async sequence of messages

Create a struct called MessageSequence that conforms to AsyncSequence with String as its element type. Inside it, create an async iterator struct called AsyncIterator that conforms to AsyncIteratorProtocol. The iterator should have a messages array with these exact strings: ["Hello", "How are you?", "Goodbye"]. Implement the next() async method to return the next message or nil when done.

Swift

struct MessageSequence: AsyncSequence {
    typealias Element = String
    struct AsyncIterator: AsyncIteratorProtocol {
        var messages = ["Hello", "How are you?", "Goodbye"]
        // Your code here
    }
    func makeAsyncIterator() -> AsyncIterator {
        return AsyncIterator()
    }
}

Need a hint?

Remember to keep track of the current message index and return nil when all messages are sent.

2

Add a limit for how many messages to process

Add a variable called maxMessages of type Int to MessageSequence to limit how many messages will be processed. Set it to 2. Pass this value to the iterator and use it to stop sending messages after reaching this limit.

Swift

struct MessageSequence: AsyncSequence {
    typealias Element = String
    let maxMessages = 2
    struct AsyncIterator: AsyncIteratorProtocol {
        var messages = ["Hello", "How are you?", "Goodbye"]
        var currentIndex = 0
        let maxMessages: Int
        mutating func next() async -> String? {
            // Your code here
        }
    }
    func makeAsyncIterator() -> AsyncIterator {
        return AsyncIterator(maxMessages: maxMessages)
    }
}

Need a hint?

Use maxMessages to stop sending messages after the limit.

3

Use a for await loop to process messages

Create an async function called processMessages(). Inside it, create an instance of MessageSequence called sequence. Use a for await loop with message as the loop variable to iterate over sequence. Inside the loop, print "Received: \(message)".

Swift

struct MessageSequence: AsyncSequence {
    typealias Element = String
    let maxMessages = 2
    struct AsyncIterator: AsyncIteratorProtocol {
        var messages = ["Hello", "How are you?", "Goodbye"]
        var currentIndex = 0
        let maxMessages: Int
        mutating func next() async -> String? {
            if currentIndex  AsyncIterator {
        return AsyncIterator(maxMessages: maxMessages)
    }
}

func processMessages() async {
    let sequence = MessageSequence()
    // Your code here
}

Need a hint?

Use for await to get each message asynchronously and print it.

4

Call the async function and print output

At the bottom of the program, call Task { await processMessages() } to run the async function and print the messages.

Swift

struct MessageSequence: AsyncSequence {
    typealias Element = String
    let maxMessages = 2
    struct AsyncIterator: AsyncIteratorProtocol {
        var messages = ["Hello", "How are you?", "Goodbye"]
        var currentIndex = 0
        let maxMessages: Int
        mutating func next() async -> String? {
            if currentIndex  AsyncIterator {
        return AsyncIterator(maxMessages: maxMessages)
    }
}

func processMessages() async {
    let sequence = MessageSequence()
    for await message in sequence {
        print("Received: \(message)")
    }
}

// Your code here

Need a hint?

Use Task { await processMessages() } to run the async code and see the printed messages.