A modern programming language that makes developers happier.

kotlinlang

-.kt

Is there a way to make smart casting work with sealed classes without having to exhaustively handle every case?
For instance I expected this to work since I only have two implementations defined for my sealed class.

I could simply add another `is Failure` handler and it doesn’t require to have `else` branch, so the way it works right now seems inconsistent.

More realistic scenario is say I have a sealed class `Result` with only `Success` and `Failure` implementations, and I want combine two different results and basically return failure if one of the results is failure and return success otherwise.

```
sealed class Result {
  object Success : Result() {
    fun s() {}
  }

  object Failure : Result() {
    fun f() {}
  }
}

val r1: Result = Result.Success
val r2: Result = Result.Failure

// pretend this combines two success results into one final success result
fun success(r1: Result.Success, r2: Result.Success) = Result.Success

val r: Result = when {
  r1 is Result.Failure -&gt; Result.Failure
  r2 is Result.Failure -&gt; Result.Failure
  r1 is Result.Success &amp;&amp; r2 is Result.Success -&gt; success(r1, r2) // smart casting works
  else -&gt; { Result.Failure } // shouldn't happen but I have to handle it
}
```

And here’s how I expected it to work but it doesn’t:
```
val r: Result = when {
  r1 is Result.Failure -&gt; Result.Failure
  r2 is Result.Failure -&gt; Result.Failure
  else -&gt; success(r1, r2) // can't smart cast
}
```

Change `is Result.Failure` to `!is Result.Success~

To allow this would make the smart cast extremely implicit and difficult to read

It would also remove the ability to check validity at runtime

The compiler adds an else branch if you exhaust the possible cases, and that branch will throw an error

I guess it’s confusing that this doesn’t require `else` branch, so the compiler does seem to know that there are no more implementations of the class?
```
val result: Result = Result.Failure
when (result) {
  is Result.Success -&gt; result.s()
  is Result.Failure -&gt; result.f()
}
```

nice, this works:
```
val r: Result = when {
  r1 !is Result.Success -&gt; Result.Failure
  r2 !is Result.Success -&gt; Result.Failure
  else -&gt; success(r1, r2)
}
```