Async sequences in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output of this async sequence code?

Consider this Swift async sequence that emits numbers 1 to 3 with a delay. What will be printed?

iOS Swift

import Foundation

func printNumbers() async {
  for await number in AsyncStream<Int>({ continuation in
    Task {
      for i in 1...3 {
        try? await Task.sleep(nanoseconds: 100_000_000)
        continuation.yield(i)
      }
      continuation.finish()
    }
  }) {
    print(number)
  }
}

Task {
  await printNumbers()
}

A 1\n2\n3

B 3\n2\n1

C No output, code deadlocks

D 1 2 3 printed on the same line

💡 Hint

AsyncStream yields values in order, and the for-await loop prints each as it arrives.

The AsyncStream yields numbers 1, 2, and 3 with a small delay. The for-await loop prints each number as it is received, resulting in 1, 2, 3 printed on separate lines.

❓ lifecycle

intermediate

What happens if you do not call continuation.finish() in AsyncStream?

In Swift's AsyncStream, what is the effect of omitting the call to continuation.finish() after yielding values?

A The sequence throws a runtime error

B The async sequence never ends and the for-await loop waits forever

C The sequence ends immediately after the last yield

D The sequence yields nil values after last yield

💡 Hint

Think about how the async sequence knows it is done.

Without calling continuation.finish(), the AsyncStream does not signal completion, so the for-await loop waits indefinitely for more values.

📝 Syntax

advanced

Which option correctly creates an AsyncStream of strings?

Choose the correct Swift code snippet that creates an AsyncStream emitting the strings "A", "B", "C".

A

let stream = AsyncStream<String> { continuation in
  ["A", "B", "C"].forEach { continuation.yield($0) }
  continuation.finish()
}

B

let stream = AsyncStream<String> { continuation in
  continuation.yield("A")
  continuation.yield("B")
  continuation.yield("C")
  continuation.finish()
}

C

let stream = AsyncStream<String> {
  continuation in
  continuation.yield("A")
  continuation.yield("B")
  continuation.yield("C")
}

D

let stream = AsyncStream<String> { continuation in
  for i in 0..<3 {
    continuation.yield(String(i))
  }
  continuation.finish()
}

💡 Hint

Check which option yields all values and calls finish properly.

Option A correctly yields all strings and calls continuation.finish() to end the stream. Option A yields numbers as strings but not the required letters. Option A misses calling finish(), so the stream never ends. Option A is valid but yields values directly without iteration; however, the question asks for the correct snippet emitting "A", "B", "C" which option A does clearly with iteration.

🔧 Debug

advanced

What error occurs with this AsyncSequence code?

Given this Swift code snippet, what error will it produce when run?

iOS Swift

func test() async {
  let stream = AsyncStream<Int> { continuation in
    continuation.yield(1)
    continuation.yield(2)
    // Missing finish call
  }
  for await value in stream {
    print(value)
  }
}

Task {
  await test()
}

A Prints 1 and 2 then exits normally

B Compilation error: missing continuation.finish()

C Runtime error: AsyncStream finished unexpectedly

D The code runs and prints 1 and 2, then hangs waiting for more values

💡 Hint

What happens if the stream never signals completion?

Because continuation.finish() is missing, the AsyncStream never signals it is done. The for-await loop prints 1 and 2 but then waits forever for more values, causing the code to hang.

🧠 Conceptual

expert

How does AsyncSequence handle backpressure in Swift concurrency?

In Swift's concurrency model, how does AsyncSequence manage backpressure when producing values faster than the consumer can process?

A AsyncSequence drops values if the consumer is slow to avoid blocking

B AsyncSequence buffers all values until the consumer is ready, potentially using unlimited memory

C AsyncSequence suspends the producer until the consumer consumes values, preventing overflow

D AsyncSequence throws an error if the producer is faster than the consumer

💡 Hint

Think about how async/await suspends tasks in Swift.

Swift's AsyncSequence suspends the producing task when the consumer is not ready, effectively applying backpressure and preventing unbounded buffering or dropping values.