Why enums are powerful in Swift - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift enum code?

Consider this Swift code using enums with associated values. What will it print?

Swift

enum Device {
    case iPhone(model: String)
    case iPad(model: String)
    case mac
}

let myDevice = Device.iPhone(model: "13 Pro")
switch myDevice {
case .iPhone(let model):
    print("iPhone model: \(model)")
case .iPad(let model):
    print("iPad model: \(model)")
case .mac:
    print("Mac computer")
}

A iPhone model: 13 Pro

B iPad model: 13 Pro

C Mac computer

D Compilation error

💡 Hint

Look at the enum case used to create myDevice and how the switch matches it.

The enum Device has cases with associated values. The instance myDevice is created as .iPhone(model: "13 Pro"). The switch matches the .iPhone case and prints the model.

🧠 Conceptual

intermediate

Why are enums with associated values powerful in Swift?

Which of the following best explains why enums with associated values are powerful in Swift?

A They allow grouping related values with different types under one type, enabling safer and clearer code.

B They only store integer values, making them faster than other types.

C They automatically generate UI elements for each case without extra code.

D They replace classes and structs entirely in Swift.

💡 Hint

Think about how enums can hold different kinds of data in one type.

Enums with associated values let you store different types of data for each case, which helps organize code and avoid errors by grouping related data clearly.

🔧 Debug

advanced

What error does this Swift enum code produce?

Examine this Swift code snippet. What error will it cause?

Swift

enum Direction {
    case north
    case south
    case east
    case west
}

let dir = Direction.north

switch dir {
case .north:
    print("Going north")
case .south:
    print("Going south")
case .east:
    print("Going east")
// Missing case for .west
}

A Error: Cannot use enum cases without raw values

B Error: Switch must be exhaustive, missing case for .west

C Runtime error: Unhandled case .west

D No error, code runs fine

💡 Hint

Swift requires switch statements on enums to cover all cases or have a default.

The switch statement does not handle the .west case, so the compiler reports a non-exhaustive switch error.

🚀 Application

advanced

How many items are in the resulting enum array?

Given this Swift enum and array, how many elements does allCases contain?

Swift

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

let allFruits = Fruit.allCases
print(allFruits.count)

A Compilation error

B 0

C 1

D 3

💡 Hint

Look at how many cases the enum has and what CaseIterable does.

The enum Fruit has three cases. Conforming to CaseIterable automatically creates allCases with all enum cases, so the count is 3.

❓ Predict Output

expert

What is the output of this Swift enum with indirect recursion?

Consider this Swift code using an indirect enum for recursive data. What will it print?

Swift

indirect enum ArithmeticExpression {
    case number(Int)
    case addition(ArithmeticExpression, ArithmeticExpression)
    case multiplication(ArithmeticExpression, ArithmeticExpression)
}

func evaluate(_ expr: ArithmeticExpression) -> Int {
    switch expr {
    case .number(let value):
        return value
    case .addition(let left, let right):
        return evaluate(left) + evaluate(right)
    case .multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}

let expr = ArithmeticExpression.addition(
    .number(2),
    .multiplication(
        .number(3),
        .number(4)
    )
)

print(evaluate(expr))

A 24

B 20

C 14

D Compilation error due to recursion

💡 Hint

Calculate the expression step by step: 2 + (3 * 4).

The expression represents 2 + (3 * 4). Multiplication happens first: 3 * 4 = 12. Then addition: 2 + 12 = 14.