Iterating enum cases with CaseIterable in Swift - Step-by-Step Execution

Concept Flow - Iterating enum cases with CaseIterable

Define enum with CaseIterable

↓

Access allCases property

↓

Start loop over allCases

↓

Process each enum case

↓

Loop ends when all cases processed

This flow shows how to define an enum with CaseIterable, then loop through all its cases using the allCases property.

Execution Sample

Swift

enum Direction: CaseIterable {
    case north, south, east, west
}

for dir in Direction.allCases {
    print(dir)
}

This code defines an enum Direction with four cases and prints each case by iterating over allCases.

Execution Table

Iteration	dir (enum case)	Action	Output
1	north	Print dir	north
2	south	Print dir	south
3	east	Print dir	east
4	west	Print dir	west
-	-	Loop ends	All cases printed

💡 All enum cases have been iterated, loop ends.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
dir	-	north	south	east	west	-

Key Moments - 3 Insights

Why can we use Direction.allCases in the for loop?

Because the enum Direction conforms to CaseIterable, Swift automatically provides the allCases collection of all enum cases, as shown in the execution_table rows 1 to 4.

What happens if we add a new case to the enum?

The allCases collection automatically includes the new case, so the loop will iterate over it without any code change, as the execution_table would have an extra iteration.

Can we use allCases with enums that don't conform to CaseIterable?

No, only enums that conform to CaseIterable have the allCases property. Without it, the code would not compile, so the loop cannot run.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of dir at iteration 3?

A east

B south

C north

D west

💡 Hint

Check the 'dir (enum case)' column at iteration 3 in the execution_table.

At which iteration does the loop end according to the execution_table?

A After iteration 3

B After iteration 5

C After iteration 4

D It never ends

💡 Hint

Look at the exit_note and the last row of the execution_table.

If we add a new case 'up' to the enum, how would the execution_table change?

A The loop would skip the new case

B It would have one more iteration with dir = up

C The code would not compile

D The output would be empty

💡 Hint

Refer to key_moments about adding new cases and how allCases updates automatically.

Concept Snapshot

enum MyEnum: CaseIterable {
    case a, b, c
}

for item in MyEnum.allCases {
    // use item
}

- CaseIterable auto-creates allCases array
- Looping over allCases visits every enum case
- Adding cases updates allCases automatically

Full Transcript

This example shows how to use the CaseIterable protocol in Swift to loop over all cases of an enum. First, we define an enum Direction with cases north, south, east, and west, and make it conform to CaseIterable. This gives us access to Direction.allCases, a collection of all enum cases. Then, we use a for loop to go through each case in allCases and print it. The execution_table shows each iteration with the current enum case and the printed output. The variable_tracker shows how the variable dir changes each iteration. Key moments clarify why allCases works only with CaseIterable enums and how adding new cases affects the loop. The visual quiz tests understanding of the iteration steps and behavior when modifying the enum. The concept snapshot summarizes the syntax and behavior for quick reference.

Practice

1. What does the CaseIterable protocol allow you to do with an enum in Swift?

easy

A. Make enum cases private

B. Access all enum cases as a collection

C. Add stored properties to enum cases

D. Change enum cases at runtime

Solution

1. Step 1: Understand the purpose of CaseIterable

   The CaseIterable protocol provides a way to access all cases of an enum as a collection.

2. Step 2: Identify what CaseIterable does not do

   It does not allow changing cases, adding stored properties, or changing access levels.

3. Final Answer:

   Access all enum cases as a collection -> Option B

4. Quick Check:

   CaseIterable = Access all cases [OK]

Hint: Remember: CaseIterable gives you all enum cases easily [OK]

Common Mistakes:

• Thinking CaseIterable allows modifying enum cases
• Confusing CaseIterable with adding properties
• Assuming CaseIterable changes access control

2. Which of the following is the correct way to declare an enum that supports iteration over all its cases using CaseIterable?

easy

A. enum Direction: CaseIterable { case north, south, east, west }

B. enum Direction { case north, south, east, west }

C. enum Direction: Iterable { case north, south, east, west }

D. enum Direction: CaseIterable() { case north, south, east, west }

Solution

1. Step 1: Check correct protocol conformance syntax

   In Swift, you conform to a protocol by listing it after a colon without parentheses.

2. Step 2: Identify the correct protocol name

   The correct protocol is CaseIterable, not Iterable, and no parentheses are used.

3. Final Answer:

   enum Direction: CaseIterable { case north, south, east, west } -> Option A

4. Quick Check:

   Correct syntax = enum Direction: CaseIterable { case north, south, east, west } [OK]

Hint: Use ': CaseIterable' without parentheses to conform [OK]

Common Mistakes:

• Adding parentheses after CaseIterable
• Using wrong protocol name like Iterable
• Forgetting to conform to CaseIterable

3. Given the enum below, what will be printed by the code?

enum Fruit: CaseIterable {
    case apple, banana, cherry
}

for fruit in Fruit.allCases {
    print(fruit)
}

medium

A. apple banana cherry

B. ["apple", "banana", "cherry"]

C. apple
banana
cherry

D. Fruit.apple Fruit.banana Fruit.cherry

Solution

1. Step 1: Understand the for loop over allCases

   The loop iterates over each case in the enum and prints it on a new line.

2. Step 2: Recognize print behavior in Swift

   Each call to print outputs the case name followed by a newline.

3. Final Answer:

   apple banana cherry -> Option C

4. Quick Check:

   Loop prints each case on separate lines [OK]

Hint: print() adds new line after each output [OK]

Common Mistakes:

• Assuming all cases print on one line
• Expecting array output instead of separate lines
• Confusing enum case names with full type names

4. What is wrong with this code snippet?

enum Color: CaseIterable {
    case red, green, blue
}

for color in Color {
    print(color)
}

medium

A. The enum cases must be strings

B. The enum must be a class to iterate

C. CaseIterable requires a raw value type

D. You must use Color.allCases to iterate, not Color directly

Solution

1. Step 1: Identify how to iterate over enum cases

   You cannot iterate over the enum type itself; you must use allCases property.

2. Step 2: Understand CaseIterable usage

   CaseIterable provides allCases which returns a collection of all enum cases for iteration.

3. Final Answer:

   You must use Color.allCases to iterate, not Color directly -> Option D

4. Quick Check:

   Use allCases for iteration [OK]

Hint: Always loop over Enum.allCases, not Enum itself [OK]

Common Mistakes:

• Trying to loop over enum type directly
• Thinking CaseIterable needs raw values
• Assuming enum must be a class

5. You want to create a menu that lists all payment methods defined in this enum:

enum PaymentMethod: CaseIterable {
    case cash, creditCard, paypal, applePay
}

Which code snippet correctly prints each payment method with a number starting from 1?

hard

A. for (index, method) in PaymentMethod.allCases.enumerated() {
print("\(index + 1). \(method)")
}

B. for method in PaymentMethod.allCases {
print("\(method + 1). \(method)")
}

C. for index in 1...PaymentMethod.allCases.count {
print("\(index). \(PaymentMethod.allCases[index])")
}

D. for method in PaymentMethod {
print("\(method.rawValue + 1). \(method)")
}

Solution

1. Step 1: Use enumerated() to get index and value

   The enumerated() method returns pairs of (index, element) for the collection.

2. Step 2: Adjust index to start from 1 and print

   Since enumerated indexes start at 0, add 1 to show numbering from 1.

3. Final Answer:

   for (index, method) in PaymentMethod.allCases.enumerated() { print("\(index + 1). \(method)") } -> Option A

4. Quick Check:

   Use enumerated() + index+1 for numbering [OK]

Hint: Use enumerated() and add 1 to index for numbering [OK]

Common Mistakes:

• Trying to add 1 directly to enum case
• Indexing allCases with 1-based index (off by one)
• Looping over enum type instead of allCases