if I do a `when` over a type system, like when { foo is A -> foo is B -> } why can the...

# announcements

[rrva]

if I do a when over a type system, like

when {
foo is A ->
foo is B ->
}

why can the compiler not figure out compile-time if the when is exhaustive without an else branch?

[diesieben07]

It can if you use a sealed class.

[Milan Hruban]

Because you cannot know about all subclasses unless it's a sealed class. Someone can take your module as a dependency, and inherit given class.

[sindrenm]

You should do a when (foo) instead:

sealed class Foo

object A : Foo()
object B : Foo()

fun main() {
    val foo: Foo = A

//  This won't work, as there are other
//  potential cases that doesn't involve 
// `foo`.
//  val bar = when {
//      foo is A -> TODO()
//      foo is B -> TODO()
//  }

    val bar = when (foo) {
        is A -> TODO()
        is B -> TODO()
    }
}

[sindrenm]

That is, your when, even if foo is an instance of a sealed class that only has an A and B subclass, isn't exhaustive,

[sindrenm]

Meaning, not every case of your when is covered. Another potential case of your when could be this, for instance:

when {
  foo is A -> TODO()
  foo is B -> TODO()
  0 == 0 -> TODO() // <--
}

[sindrenm]

Dumb example, but I hope you see my point. simple smile