Switch must be exhaustive in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this exhaustive switch?

Consider the following Swift code with an exhaustive switch on an enum. What will it print?

Swift

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

let dir = Direction.east

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

A Going east

B Going north

C Compilation error: switch not exhaustive

D Runtime error

💡 Hint

Check if all enum cases are covered in the switch.

The switch covers all cases of the enum Direction, so it is exhaustive. The variable dir is .east, so it prints "Going east".

❓ Predict Output

intermediate

What error does this non-exhaustive switch cause?

What error will this Swift code produce?

Swift

enum Color {
    case red, green, blue
}

let c = Color.green

switch c {
case .red:
    print("Red")
case .blue:
    print("Blue")
}

A Compilation error: switch must be exhaustive

B Runtime error: missing case green

C Prints nothing

D Prints "Green"

💡 Hint

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

The switch does not cover the .green case and has no default, so the compiler reports an error that the switch is not exhaustive.

🧠 Conceptual

advanced

Why must switches on enums be exhaustive in Swift?

Why does Swift require switches on enums to be exhaustive?

A To make the code run faster by skipping unhandled cases

B To allow the compiler to optimize memory usage

C To ensure all possible cases are handled, preventing unexpected behavior at runtime

D Because Swift does not support default cases in switches

💡 Hint

Think about safety and predictability in code.

Requiring exhaustive switches ensures the programmer handles every possible case, avoiding bugs from unhandled cases at runtime.

📝 Syntax

advanced

Which switch is exhaustive for this enum?

Given the enum below, which switch statement is exhaustive and compiles without error?

Swift

enum Status {
    case success
    case failure
    case unknown
}

A

switch status {
case .success:
    print("Success")
case .failure:
    print("Failure")
}

B

switch status {
case .success:
    print("Success")
case .failure:
    print("Failure")
case .unknown:
    print("Unknown")
}

C

switch status {
default:
    print("Any")
}

D

switch status {
case .success, .failure:
    print("Known")
}

💡 Hint

Check if all cases are covered or if a default is used.

Option B covers all three cases explicitly, so it is exhaustive. Options A and B miss the .unknown case.

🚀 Application

expert

How many cases must be handled in this switch?

Given this enum with associated values, how many cases must a switch handle to be exhaustive?

Swift

enum Result {
    case success(Int)
    case failure(String)
    case pending
}

A 4 cases because success and failure have associated values

B 2 cases: success and failure only, pending is optional

C 1 case with a default to cover all

D 3 cases: success, failure, and pending

💡 Hint

Remember each enum case counts separately regardless of associated values.

All three cases must be handled explicitly or with a default. Associated values do not increase the number of cases, but each case is distinct.