Kotlin Enums and Sealed Classes

enum class Size { SMALL, MEDIUM, LARGE }

val mine = Size.MEDIUM
println(mine)               // MEDIUM
println(mine.ordinal)       // 1
println(Size.entries)       // [SMALL, MEDIUM, LARGE]

• Constants are written in capitals, separated by commas.
• name is the constant's name as a String; ordinal is its position from 0.
• Size.entries lists every constant (Kotlin 1.9+; older code uses Size.values()).
• Size.valueOf("LARGE") converts text to a constant and throws if there's no match. For safe lookups, use Size.entries.find { it.name == text }.

Enum constants can carry data and behaviour. Add a constructor, and end the list of constants with a semicolon before any members:

enum class Coffee(val label: String, val price: Double) {
    ESPRESSO("Espresso", 2.20),
    LATTE("Latte", 3.10),
    FLAT_WHITE("Flat white", 3.30);

    fun priceFor(cups: Int) = price * cups
}

Each constant passes its own values to the constructor. This keeps related data together and avoids parallel lists or maps that can fall out of step.

A sealed class or interface allows only the subclasses declared in the same package and module, so the compiler knows the complete list:

sealed interface LoadState {
    data object Loading : LoadState
    data class Success(val items: List<String>) : LoadState
    data class Error(val message: String) : LoadState
}

• Each case can be a data class with its own properties, or a data object when it carries no data.
• Unlike enum constants, each case can have a different shape.
• Sealed interfaces are usually preferred today, because a class can implement several interfaces.

fun render(state: LoadState): String = when (state) {
    LoadState.Loading -> "Loading..."
    is LoadState.Success -> "${state.items.size} items"
    is LoadState.Error -> "Error: ${state.message}"
}

• No else is needed, because every case is covered.
• is checks smart cast the value, so state.items and state.message are available.
• If someone adds a fourth case, every when like this stops compiling until the new case is handled. Avoid adding else to these, or you lose that protection.

Enum constants are ordered by the position you declared them in, so you can compare them with <, > and ranges. Declaring sizes from smallest to largest pays off here:

enum class Size { SMALL, MEDIUM, LARGE }

println(Size.LARGE > Size.SMALL)                       // true
println(Size.entries.filter { it >= Size.MEDIUM })     // [MEDIUM, LARGE]

Because the order comes from the declaration, inserting a new constant in the middle changes every ordinal after it. That's fine inside a running program, but never save ordinal to a file or database; save name instead, which stays the same.

Sometimes each constant needs different behaviour, not just different data. Declare an abstract function in the enum and give every constant its own body:

enum class Op(val symbol: String) {
    PLUS("+") { override fun apply(a: Int, b: Int) = a + b },
    TIMES("*") { override fun apply(a: Int, b: Int) = a * b };

    abstract fun apply(a: Int, b: Int): Int
}

for (op in Op.entries) println("6 ${op.symbol} 7 = ${op.apply(6, 7)}")
// 6 + 7 = 13
// 6 * 7 = 42

The compiler insists that every constant implements apply, so a new operation can't be added half-finished. Enum functions can also use entries to move between constants, which suits cycles such as traffic lights:

enum class Light { RED, AMBER, GREEN;
    fun next() = entries[(ordinal + 1) % entries.size]
}
println(Light.GREEN.next())    // RED