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()
    }
}

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)
    }
}

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
}

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

Hint

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

Practice

1. What is the main purpose of using AsyncSequence in Swift?

easy

A. To create synchronous loops that block until completion

B. To define static arrays with fixed values

C. To handle streams of values that arrive over time without blocking the program

D. To perform immediate calculations without delay

Solution

1. Step 1: Understand AsyncSequence purpose

   AsyncSequence is designed to handle values that come asynchronously over time, like events or data streams.

2. Step 2: Compare options with AsyncSequence use

   Only To handle streams of values that arrive over time without blocking the program correctly describes handling streams without blocking, which is the key feature of AsyncSequence.

3. Final Answer:

   To handle streams of values that arrive over time without blocking the program -> Option C

4. Quick Check:

   AsyncSequence = handle async streams [OK]

Hint: AsyncSequence handles values arriving over time without blocking [OK]

Common Mistakes:

• Confusing AsyncSequence with synchronous loops
• Thinking AsyncSequence is for static data
• Assuming it blocks program execution

2. Which of the following is the correct syntax to iterate over an AsyncSequence named numbers?

easy

A. for await number in numbers { print(number) }

B. for number in numbers { print(number) }

C. while let number = numbers.next() { print(number) }

D. numbers.forEach { print($0) }

Solution

1. Step 1: Recall AsyncSequence iteration syntax

   AsyncSequence requires asynchronous iteration using for await to wait for values.

2. Step 2: Check each option

   for await number in numbers { print(number) } uses for await, which is correct. for number in numbers { print(number) } is synchronous, C is invalid syntax for AsyncSequence, and D is not supported.

3. Final Answer:

   for await number in numbers { print(number) } -> Option A

4. Quick Check:

   AsyncSequence loops use for await [OK]

Hint: Use 'for await' to loop over AsyncSequence values [OK]

Common Mistakes:

• Using regular for loop without await
• Trying to call next() synchronously
• Using forEach which is not async-compatible

3. What will be printed by the following Swift code?

struct Counter: AsyncSequence {
  typealias Element = Int
  struct AsyncIterator: AsyncIteratorProtocol {
    var count = 1
    mutating func next() async -> Int? {
      guard count <= 3 else { return nil }
      defer { count += 1 }
      return count
    }
  }
  func makeAsyncIterator() -> AsyncIterator {
    AsyncIterator()
  }
}

let counter = Counter()
Task {
  for await number in counter {
    print(number)
  }
}

medium

A. 1 2 3

B. 0 1 2

C. 1 2 3 4

D. No output, code will not compile

Solution

1. Step 1: Analyze AsyncIterator next() method

   The iterator returns count starting at 1, increments after returning, and stops after 3.

2. Step 2: Trace iteration values

   Values returned are 1, then 2, then 3, then nil to end the loop.

3. Final Answer:

   1 2 3 -> Option A

4. Quick Check:

   AsyncSequence yields 1,2,3 then ends [OK]

Hint: Check next() return and guard condition carefully [OK]

Common Mistakes:

• Assuming count starts at 0
• Forgetting defer increments count after return
• Expecting 4 as output

4. Identify the error in this AsyncSequence implementation:

struct SimpleAsync: AsyncSequence {
  typealias Element = String
  struct AsyncIterator: AsyncIteratorProtocol {
    func next() async -> String? {
      return "Hello"
    }
  }
  func makeAsyncIterator() -> AsyncIterator {
    AsyncIterator()
  }
}

medium

A. makeAsyncIterator() must be async

B. next() should be mutating to update state

C. AsyncIterator must be a class, not a struct

D. Element type cannot be String

Solution

1. Step 1: Understand AsyncIteratorProtocol requirements

   The next() method often needs to update internal state, so it must be marked mutating in a struct.

2. Step 2: Check the code's next() method

   Here, next() is not mutating but returns a constant string repeatedly, which is incorrect for iteration.

3. Final Answer:

   next() should be mutating to update state -> Option B

4. Quick Check:

   next() mutating required in struct iterator [OK]

Hint: next() in struct iterator must be mutating if state changes [OK]

Common Mistakes:

• Thinking AsyncIterator must be a class
• Making makeAsyncIterator async unnecessarily
• Believing String cannot be Element type

5. You want to create an AsyncSequence that emits only even numbers from 2 to 10 inclusive. Which implementation correctly achieves this?

hard

A. struct EvenNumbers: AsyncSequence {
typealias Element = Int
struct AsyncIterator: AsyncIteratorProtocol {
var current = 2
mutating func next() async -> Int? {
guard current < 10 else { return nil }
defer { current += 2 }
return current
}
}
func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
}

B. struct EvenNumbers: AsyncSequence {
typealias Element = Int
struct AsyncIterator: AsyncIteratorProtocol {
var current = 1
mutating func next() async -> Int? {
guard current <= 10 else { return nil }
defer { current += 1 }
return current * 2
}
}
func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
}

C. struct EvenNumbers: AsyncSequence {
typealias Element = Int
struct AsyncIterator: AsyncIteratorProtocol {
var current = 0
mutating func next() async -> Int? {
guard current <= 10 else { return nil }
current += 2
return current
}
}
func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
}

D. struct EvenNumbers: AsyncSequence {
typealias Element = Int
struct AsyncIterator: AsyncIteratorProtocol {
var current = 2
mutating func next() async -> Int? {
if current > 10 { return nil }
let result = current
current += 2
return result
}
}
func makeAsyncIterator() -> AsyncIterator { AsyncIterator() }
}

Solution

1. Step 1: Identify required sequence

   Even numbers from 2 to 10 inclusive: 2, 4, 6, 8, 10 exactly.

2. Step 2: Trace execution of each

   A (< 10, defer +=2): 2,4,6,8 (stops at current=10). Misses 10.
   B (*2 on odds): 2,4,6,8,10,12,... overshoots.
   C (<=10, +=2 first): 2,4,6,8,10,12 extra.
   D (if >10 nil, result first): 2,4,6,8,10 perfect.

3. Final Answer:

   if current > 10 { return nil }
   let result = current
   current += 2
   return result -> Option D

4. Quick Check:

   Only D emits exactly 2,4,6,8,10 [OK]

Hint: Return current before increment; stop when current > 10 [OK]

Common Mistakes:

• Incrementing before returning causing off-by-one errors
• Incorrect guard conditions excluding last value
• Multiplying inside next() causing wrong sequence