Enum with when exhaustive check in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of exhaustive when with enum

What is the output of this Kotlin code using an exhaustive when expression with an enum?

Kotlin

enum class Direction { NORTH, SOUTH, EAST, WEST }

fun describe(direction: Direction): String {
    return when(direction) {
        Direction.NORTH -> "Up"
        Direction.SOUTH -> "Down"
        Direction.EAST -> "Right"
        Direction.WEST -> "Left"
    }
}

fun main() {
    println(describe(Direction.EAST))
}

A East

B Right

C Direction.EAST

D Compilation error due to missing else

💡 Hint

The when expression covers all enum cases, so no else branch is needed.

The when expression is exhaustive because it handles all enum values. For Direction.EAST, it returns "Right".

❓ Predict Output

intermediate

What error occurs with non-exhaustive when on enum?

What error does this Kotlin code produce when compiled?

Kotlin

enum class Color { RED, GREEN, BLUE }

fun colorName(color: Color): String {
    return when(color) {
        Color.RED -> "Red"
        Color.GREEN -> "Green"
    }
}

fun main() {
    println(colorName(Color.BLUE))
}

A Compilation error: 'when' expression must be exhaustive

B Runtime exception: No matching branch found

C Prints null

D Prints empty string

💡 Hint

Kotlin requires when expressions on enums to cover all cases or have an else branch.

The when expression is missing a branch for Color.BLUE and no else branch is provided, so Kotlin reports a compilation error.

🔧 Debug

advanced

Why does this exhaustive when cause unreachable code?

This Kotlin code causes a compilation error about unreachable code. Why?

Kotlin

enum class Status { STARTED, RUNNING, FINISHED }

fun checkStatus(status: Status): String {
    return when(status) {
        Status.STARTED -> "Started"
        Status.RUNNING -> "Running"
        Status.FINISHED -> "Finished"
        else -> "Unknown"
    }
}

A The when expression is missing a case

B The else branch is required for exhaustive when on enums

C The enum has a hidden value causing unreachable code

D The else branch is unreachable because all enum cases are already handled

💡 Hint

When all enum cases are covered, else branch is not needed and causes unreachable code.

Since all enum values are handled explicitly, the else branch can never be reached, causing a compilation error.

🧠 Conceptual

advanced

Exhaustive when with sealed class vs enum

Which statement is true about using when expressions with enums and sealed classes in Kotlin?

A Sealed classes require else branches but enums do not

B Enums require else branches but sealed classes do not

C Both enums and sealed classes require exhaustive when expressions without else branches if all cases are covered

D Neither enums nor sealed classes support exhaustive when expressions

💡 Hint

Both enums and sealed classes have a fixed set of subclasses or values known at compile time.

Kotlin enforces exhaustive when expressions for both enums and sealed classes if all cases are covered, so else branches are not needed.

❓ Predict Output

expert

Output of nested when with enum and smart cast

What is the output of this Kotlin code that uses nested when expressions and smart casts with enums?

Kotlin

enum class Mode { ON, OFF }

fun modeMessage(mode: Mode?): String {
    return when(mode) {
        null -> "No mode"
        Mode.ON -> when(mode) {
            Mode.ON -> "Mode is ON"
            Mode.OFF -> "Mode is OFF"
        }
        Mode.OFF -> "Mode is OFF"
    }
}

fun main() {
    println(modeMessage(Mode.ON))
}

A Mode is ON

B Mode is OFF

C No mode

D Compilation error due to non-exhaustive when

💡 Hint

The inner when uses the same enum value as the outer when branch.

The outer when matches Mode.ON, then the inner when also matches Mode.ON, returning "Mode is ON".

Practice

1. What does the Kotlin when expression require when used with an enum class?

easy

A. All enum cases must be handled to ensure exhaustive checking.

B. Only one enum case needs to be handled.

C. The when expression cannot be used with enums.

D. You must use else even if all enum cases are handled.

Solution

1. Step 1: Understand enum and when usage

   Kotlin enums define fixed values. The when expression can check these values.

2. Step 2: Check compiler requirements for exhaustive when

   Kotlin requires all enum cases to be handled in when to be exhaustive, avoiding missing cases.

3. Final Answer:

   All enum cases must be handled to ensure exhaustive checking. -> Option A

4. Quick Check:

   Exhaustive when = all enum cases handled [OK]

Hint: Remember: when with enum must cover all cases [OK]

Common Mistakes:

• Forgetting to handle all enum values
• Using else unnecessarily when all cases are covered
• Assuming when can't be exhaustive with enums

2. Which of the following is the correct syntax for a when expression that exhaustively checks all values of this enum?

enum class Direction { NORTH, SOUTH, EAST, WEST }

easy

A. when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S"; Direction.EAST -> "E"; Direction.WEST -> "W" }

B. when(dir) { Direction.NORTH, Direction.SOUTH -> "NS" }

C. when(dir) { "N" -> Direction.NORTH; "S" -> Direction.SOUTH }

D. when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S" }

Solution

1. Step 1: Check all enum values handled

   when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S"; Direction.EAST -> "E"; Direction.WEST -> "W" } lists all four enum values with their results, no else needed.

2. Step 2: Verify syntax correctness

   when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S"; Direction.EAST -> "E"; Direction.WEST -> "W" } uses correct when syntax with enum constants and returns strings.

3. Final Answer:

   when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S"; Direction.EAST -> "E"; Direction.WEST -> "W" } -> Option A

4. Quick Check:

   All enum cases handled without else = when(dir) { Direction.NORTH -> "N"; Direction.SOUTH -> "S"; Direction.EAST -> "E"; Direction.WEST -> "W" } [OK]

Hint: List all enum values explicitly for exhaustive when [OK]

Common Mistakes:

• Using else when all enum cases are handled
• Missing some enum values in when
• Using wrong types in when branches

3. What will be the output of this Kotlin code?

enum class Light { RED, GREEN, YELLOW }

fun signalMessage(light: Light) = when(light) {
    Light.RED -> "Stop"
    Light.GREEN -> "Go"
    Light.YELLOW -> "Caution"
}

fun main() {
    println(signalMessage(Light.YELLOW))
}

medium

A. Stop

B. Go

C. Caution

D. Compilation error

Solution

1. Step 1: Identify the enum value passed

   The function is called with Light.YELLOW.

2. Step 2: Match enum value in when expression

   The when expression returns "Caution" for Light.YELLOW.

3. Final Answer:

   Caution -> Option C

4. Quick Check:

   Light.YELLOW maps to "Caution" [OK]

Hint: Match enum value to when branch to find output [OK]

Common Mistakes:

• Confusing enum values with strings
• Assuming else is needed for exhaustive when
• Expecting compilation error due to missing else

4. This Kotlin code does not compile. What is the error?

enum class Status { SUCCESS, ERROR, LOADING }

fun getStatusMessage(status: Status) = when(status) {
    Status.SUCCESS -> "Done"
    Status.ERROR -> "Failed"
}

medium

A. Missing else branch in when expression

B. Not all enum cases handled in when expression

C. Incorrect enum class declaration

D. Function return type missing

Solution

1. Step 1: Check enum cases handled in when

   Only Status.SUCCESS and Status.ERROR are handled; Status.LOADING is missing.

2. Step 2: Understand Kotlin's exhaustive when requirement

   When used as expression, all enum cases must be handled or else an else branch is needed.

3. Final Answer:

   Not all enum cases handled in when expression -> Option B

4. Quick Check:

   Missing enum case causes compilation error [OK]

Hint: Cover all enum values or add else to fix compilation [OK]

Common Mistakes:

• Assuming else is optional when missing enum cases
• Ignoring missing enum values in when
• Thinking function return type causes error

5. Given this enum and function, how can you modify getDayType to use an exhaustive when expression without an else branch?

enum class Day { MON, TUE, WED, THU, FRI, SAT, SUN }

fun getDayType(day: Day): String = when(day) {
    Day.SAT, Day.SUN -> "Weekend"
    Day.MON, Day.TUE, Day.WED, Day.THU, Day.FRI -> "Weekday"
}

medium

A. Add an else branch to cover any missing cases.

B. Add all enum values explicitly in separate branches without combining.

C. Add a default return statement after when.

D. Keep combined branches as is; Kotlin treats it as exhaustive.

Solution

1. Step 1: Analyze current when branches

   The branches cover Day.SAT, Day.SUN and Day.MON, Day.TUE, Day.WED, Day.THU, Day.FRI, which includes all seven enum values.

2. Step 2: Verify Kotlin's exhaustive when rules

   Kotlin considers the when exhaustive if all enum cases are explicitly covered across branches, even when grouped with commas in the same branch. No else branch is needed.

3. Final Answer:

   Keep combined branches as is; Kotlin treats it as exhaustive. -> Option D

4. Quick Check:

   Grouped coverage of all enum cases = exhaustive without else [OK]

Hint: Comma-grouped enum values in branches make when exhaustive [OK]

Common Mistakes:

• Thinking combined branches don't count as exhaustive
• Believing you must use separate branches for each enum value
• Unnecessarily adding an else branch