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".