Async sequences in iOS Swift

Introduction

Async sequences let your app handle data that comes over time without freezing the screen. They help you work with streams of values that arrive one by one.

Loading messages in a chat app as they arrive

Fetching live sensor data continuously

Downloading parts of a file step by step

Receiving updates from a server in real time

Syntax

iOS Swift

for await item in asyncSequence {
    // use item here
}

You use for await to loop over values that come asynchronously.

The asyncSequence can be any source that sends values over time.

Examples

This example creates a simple async sequence of numbers 1 and 2, then prints them.

iOS Swift

let numbers = AsyncStream<Int> { continuation in
    continuation.yield(1)
    continuation.yield(2)
    continuation.finish()
}

for await number in numbers {
    print(number)
}

This function returns an async sequence counting down from 3 to 1.

iOS Swift

func countdown() -> AsyncStream<Int> {
    AsyncStream { continuation in
        for i in (1...3).reversed() {
            continuation.yield(i)
        }
        continuation.finish()
    }
}

for await count in countdown() {
    print(count)
}

Sample App

This SwiftUI app shows a list of messages that appear one by one after pressing the button. It uses an async sequence to simulate receiving messages over time.

iOS Swift

import SwiftUI

struct ContentView: View {
    @State private var messages: [String] = []

    var body: some View {
        VStack {
            List(messages, id: \.self) { message in
                Text(message)
            }
            Button("Start Receiving") {
                Task {
                    await receiveMessages()
                }
            }
        }
        .padding()
    }

    func receiveMessages() async {
        let messageStream = AsyncStream<String> { continuation in
            DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
                continuation.yield("Hello")
            }
            DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
                continuation.yield("How are you?")
            }
            DispatchQueue.global().asyncAfter(deadline: .now() + 3) {
                continuation.yield("Goodbye!")
                continuation.finish()
            }
        }

        for await message in messageStream {
            messages.append(message)
        }
    }
}

Important Notes

Async sequences help keep your app responsive by not blocking the main thread.

Use Task to start async work from UI events like button taps.

Remember to call continuation.finish() to end the sequence.

Summary

Async sequences let you handle data that arrives over time smoothly.

Use for await to loop through async sequences.

They are great for live updates, streams, and continuous data.

Practice

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

easy

A. To perform synchronous loops faster

B. To create static arrays of data

C. To handle data that arrives over time asynchronously

D. To store data permanently on disk

Solution

1. Step 1: Understand async sequences concept

   Async sequences allow handling data that comes in over time, not all at once.

2. Step 2: Compare options with async sequence use

   Only To handle data that arrives over time asynchronously describes handling data arriving asynchronously, which matches async sequences.

3. Final Answer:

   To handle data that arrives over time asynchronously -> Option C

4. Quick Check:

   Async sequences = handle data over time [OK]

Hint: Async sequences handle data arriving over time [OK]

Common Mistakes:

• Thinking async sequences create static data
• Confusing async sequences with synchronous loops
• Assuming async sequences store data permanently

2. Which of the following is the correct syntax to iterate over an async sequence named stream?

easy

A. for value in stream.await { print(value) }

B. for value in await stream { print(value) }

C. await for value in stream { print(value) }

D. for await value in stream { print(value) }

Solution

1. Step 1: Recall async sequence iteration syntax

   Swift uses for await to loop over async sequences.

2. Step 2: Match syntax with options

   Only for await value in stream { print(value) } uses for await value in stream, which is correct syntax.

3. Final Answer:

   for await value in stream { print(value) } -> Option D

4. Quick Check:

   Use 'for await' to loop async sequences [OK]

Hint: Use 'for await' before the loop variable [OK]

Common Mistakes:

• Placing 'await' after 'for' incorrectly
• Using 'await' inside the loop variable
• Trying to access '.await' property on sequence

3. Given the async sequence numbers that yields 1, 2, 3, what will this code print?

for await num in numbers {
  print(num * 2)
}

medium

A. 2 4 6

B. 1 2 3

C. 0 2 4

D. Error: Cannot multiply async sequence

Solution

1. Step 1: Understand the async sequence values

   The sequence yields 1, 2, and 3 asynchronously.

2. Step 2: Calculate output inside loop

   Each number is multiplied by 2 and printed: 2, 4, 6.

3. Final Answer:

   2 4 6 -> Option A

4. Quick Check:

   Multiply each yielded value by 2 [OK]

Hint: Multiply each async value inside the loop [OK]

Common Mistakes:

• Printing original values without multiplication
• Expecting synchronous output order
• Thinking async sequences cause errors here

4. What is wrong with this code snippet?

for num in numbers {
  print(num)
}

Assuming numbers is an async sequence.

medium

A. Should use 'while' loop instead of 'for'

B. Missing 'await' keyword before the loop variable

C. Async sequences cannot be iterated

D. Missing 'async' keyword in function declaration

Solution

1. Step 1: Identify iteration syntax for async sequences

   Async sequences require 'for await' to iterate properly.

2. Step 2: Check code snippet

   The code uses 'for num in numbers' without 'await', which is incorrect.

3. Final Answer:

   Missing 'await' keyword before the loop variable -> Option B

4. Quick Check:

   Async sequence loops need 'for await' [OK]

Hint: Always use 'for await' with async sequences [OK]

Common Mistakes:

• Omitting 'await' in the loop
• Thinking async sequences can't be iterated
• Confusing async function declaration with loop syntax

5. You want to collect the first 3 values from an async sequence updates into an array. Which code correctly does this?

hard

A. var results = []
for await update in updates {
results.append(update)
if results.count == 3 { break }
}

B. var results = []
for update in updates {
results.append(update)
if results.count == 3 { break }
}

C. var results = []
while let update = await updates.next() {
results.append(update)
if results.count == 3 { break }
}

D. var results = []
updates.forEach { update in
results.append(update)
if results.count == 3 { break }
}

Solution

1. Step 1: Understand async sequence iteration and breaking

   Use 'for await' to iterate async sequences and break when count reaches 3.

2. Step 2: Evaluate each option

   var results = [] for await update in updates { results.append(update) if results.count == 3 { break } } uses 'for await' with break after 3 items, correct. var results = [] for update in updates { results.append(update) if results.count == 3 { break } } lacks 'await'. var results = [] while let update = await updates.next() { results.append(update) if results.count == 3 { break } } uses invalid syntax for async sequences. var results = [] updates.forEach { update in results.append(update) if results.count == 3 { break } } uses 'forEach' which doesn't support async iteration or breaking.

3. Final Answer:

   var results = [] for await update in updates { results.append(update) if results.count == 3 { break } } -> Option A

4. Quick Check:

   Use 'for await' and break after 3 items [OK]

Hint: Use 'for await' and break after collecting 3 items [OK]

Common Mistakes:

• Omitting 'await' in the loop
• Using synchronous loops on async sequences
• Trying to use 'forEach' with async sequences