Async sequences (AsyncSequence) in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an asynchronous sequence using AsyncSequence protocol.

Swift

struct NumberIterator: AsyncIteratorProtocol {
    typealias Element = Int
    var current = 1
    mutating func next() async -> [1] {
        guard current <= 3 else { return nil }
        defer { current += 1 }
        return current
    }
}

struct NumberSequence: AsyncSequence {
    typealias Element = Int
    func makeAsyncIterator() -> NumberIterator {
        return NumberIterator()
    }
}

Drag options to blanks, or click blank then click option'

AInt?

BInt

CString?

DVoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-optional return type for next()

Returning a non-async function

The next() method of AsyncIteratorProtocol must return an optional element (Element?) asynchronously. Here, since Element is Int, the return type is Int?.

2fill in blank

medium

Complete the code to asynchronously iterate over the NumberSequence and print each number.

Swift

let sequence = NumberSequence()
Task {
    var iterator = sequence.makeAsyncIterator()
    while let number = await [1] {
        print(number)
    }
}

Drag options to blanks, or click blank then click option'

Aiterator.next()

Bsequence.next()

Citerator.next

Dsequence.makeAsyncIterator()

Attempts:

3 left

💡 Hint

Common Mistakes

Calling next() on the sequence instead of the iterator

Forgetting to use await

To get the next element asynchronously, call await iterator.next(). This returns the next optional element from the iterator.

3fill in blank

hard

Fix the error in the async for loop to iterate over the sequence correctly.

Swift

let sequence = NumberSequence()
Task {
    for await [1] in sequence {
        print([1])
    }
}

Drag options to blanks, or click blank then click option'

Avalue

Bnum

Citem

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using inconsistent variable names inside the loop

Using reserved keywords as variable names

The variable name inside the loop can be any valid identifier. Here, number is a clear and descriptive name for each element in the sequence.

4fill in blank

hard

Fill both blanks to create a filtered async sequence that yields only even numbers.

Swift

struct EvenNumberSequence: AsyncSequence {
    typealias Element = Int
    let baseSequence: NumberSequence
    func makeAsyncIterator() -> Iterator {
        return Iterator(baseIterator: baseSequence.makeAsyncIterator() as! NumberIterator)
    }
    struct Iterator: AsyncIteratorProtocol {
        typealias Element = Int
        var baseIterator: NumberIterator
        mutating func next() async -> [1] {
            while let number = await baseIterator.next() {
                if number [2] 2 == 0 {
                    return number
                }
            }
            return nil
        }
    }
}

Drag options to blanks, or click blank then click option'

AInt?

BInt

C%

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-optional return type for next()

Using equality operator instead of modulo for even check

The next() method returns an optional Int (Int?). To check if a number is even, use the modulo operator % to test if the remainder when divided by 2 is zero.

5fill in blank

hard

Fill all three blanks to create a dictionary from an async sequence where keys are string versions of numbers and values are the numbers themselves, filtering only numbers greater than 1.

Swift

func createDictionary(from sequence: NumberSequence) async -> [String: Int] {
    var result = [String: Int]()
    var iterator = sequence.makeAsyncIterator()
    while let number = await [1] {
        if number [2] 1 {
            result[[3]] = number
        }
    }
    return result
}

Drag options to blanks, or click blank then click option'

Aiterator.next()

B>

CString(number)

Dnumber.next()

Attempts:

3 left

💡 Hint

Common Mistakes

Calling next() on the wrong variable

Using wrong comparison operator

Not converting number to string for dictionary key

To get the next element asynchronously, call await iterator.next(). To filter numbers greater than 1, use >. To use the number as a key in the dictionary, convert it to a string with String(number).

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