```
interface Runner
interface Jumper
interface Swimmer
interface Diver
fun <T> testAllAthleticism(t: T) where T : Runner, T : Jumper, T : Swimmer, T : Diver {}
fun <T> testGroundAthleticism(t: T) where T : Runner, T : Jumper {}
fun <T> testWaterAthleticism(t: T) where T : Swimmer, T : Diver {}
fun <T> testSwimming(t: T) where T : Swimmer {}
fun <T> runTest(t: T) {
when {
t is Runner && t is Jumper && t is Swimmer && t is Diver -> testAllAthleticism(t) // compiler error
t is Runner && t is Jumper -> testGroundAthleticism(t) // compiler error
t is Swimmer && t is Diver -> testWaterAthleticism(t) // compiler error
t is Swimmer -> testSwimming(t) // works
}
}
```

I can’t figure out how to get this kind of code to work, if I understand correctly this might just be a short coming of the capabilities of the compiler in regards to smart casting, which is understandable.

Is there anyway I can unsafely cast this? I couldn’t find out how to do multiple `as`

casts to make this work.