```val result = when { guess > answer -> "Lower!" guess < answer -> "Higher!" guess == a...

# getting-started

[Ray Rahke]

val result = when {
    guess > answer -> "Lower!"
    guess < answer -> "Higher!"
    guess == answer -> "Yes!"
}

it says it is not exhaustive. it logically is.

[Harold Martin]

What are the types of guess and answer?

[Ray Rahke]

Int

[Casey Brooks]

When blocks are currently pretty limited in determining when they're exhaustive. It really only supports enums, sealed classes, and Boolean values, but cannot determine when a set of expressions covers all cases.

The fix is to add an else -> condition, or turn your final == condition into the else

[Ray Rahke]

Yeah I figured that out. Just a bit of a shame it can't infer that already

[Ray Rahke]

readability suffers a bit here

[Casey Brooks]

Furthermore, if you are using when without a subject, the branches are arbitrary expressions so you'll always need to provide an else. It can only be smart when it has a specific value it's checking conditions for (when(guess)), and then only in some specific circumstances

[Ray Rahke]

yeah, but when(guess) doesn't have a supported syntax for this iirc

[Ray Rahke]

when (guess) {
> answer ->

[Ray Rahke]

not a thing

[ephemient]

it sort of exists, with some custom wrappers

value class LessThan(val value: Int) {
    operator fun contains(other: Int): Boolean = other < value
}
value class GreaterThan(val value: Int) {
    operator fun contains(other: Int): Boolean = other > value
}

when (guess) {
    in LessThan(answer) -> ...
    in GreaterThan(answer) -> ...
    else -> ...
}

or using ranges such as Int.MIN_VALUE..<answer, but the compiler still requires else

[ephemient]

https://youtrack.jetbrains.com/issue/KT-34753/When-expression-must-be-exhaustive-add-static-check-in-branches-of-comparing-operation