Kotlin: catch extension - exception

Question

Because Kotlin doesn't support multiple catch like java does, I want to create extension to partially solve the problem.
fun <T: Throwable> (() -> Unit).catch(vararg exceptions: KClass<T>, catchBlock: (Throwable) -> Unit) {
try {
this()
} catch (e: Throwable) {
if (e::class in exceptions) catchBlock(e) else throw e
}
}
That can be called like this:
{
throw NotImplementedException.exception()
}.catch(NotImplementedException::class) {
//handle it
}
But the problem is that if to pass several arguments with different types it doesn't work (Type inference failed):
{
throw IndexOutOfBoundsException()
}.catch(NotImplementedException::class, IndexOutOfBoundsException::class) {
}
So how can I change signature of the extension to catch several exceptions of different types?

Answer 1

Let's look at the types of the two arugments you're trying to pass to your function:
val kclass1: KClass<NotImplementedException> = NotImplementedException::class
val kclass2: KClass<IndexOutOfBoundsException> = IndexOutOfBoundsException::class
While they are both KClass instances, their type parameters are different - NotImplementedException and IndexOutOfBoundsException. This means that no generic T type parameter can be found for the function that would fit both of these types exactly.
Just for demonstration and explanation purposes, you could help type inference by casting both of your types to KClass<Throwable> (or KClass<Exception>, or KClass<RuntimeException, you get the idea) yourself, that way it could figure out the generic type:
{
throw IndexOutOfBoundsException()
}.catch(NotImplementedException::class as KClass<Throwable>, IndexOutOfBoundsException::class as KClass<Throwable>) {
println("Caught something: $it")
}
But the real solution is to use the out keyword to specify use-site variance for the type parameter of the KClass instances:
fun <T : Throwable> (() -> Unit).catch(vararg exceptions: KClass<out T>, catchBlock: (Throwable) -> Unit) {
try {
this()
} catch (e: Throwable) {
if (e::class in exceptions) catchBlock(e) else throw e
}
}
This way the compiler will find a type for T that's both a subtype of Throwable as specified, and is a supertype of all argument's KClass type parameters - this will be RuntimeException in this case, which you can find out by opening intention actions on the catch call (Alt + Enter on Windows, ⌥↩ on macOS) and choosing Add explicit type arguments. This will produce the following:
{
throw IndexOutOfBoundsException()
}.catch<RuntimeException>(NotImplementedException::class, IndexOutOfBoundsException::class) {
println("Caught something: $it")
}