Help newbies to handle exceptions in coroutines

I can’t figure how to catch the exceptions thrown from a launch block. I don’t understand how to use the CoroutineExceptionHandler. I think that the Try pattern is quite heavy (https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/src/test/kotlin/kotlinx/coroutines/experimental/Try.kt). The CompletableFuture wrapper works as expected (simply), but it requires the jdk8 lib. Thanks for this masterpiece !

import kotlinx.coroutines.experimental.delay
import kotlinx.coroutines.experimental.future.await
import kotlinx.coroutines.experimental.future.future
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking
import org.junit.Ignore
import org.junit.Test
import java.util.concurrent.atomic.AtomicBoolean

class CoroutinesTest {

    class TestException: Exception("test exception")

    @Test
    @Ignore("not that way...")
    fun testExceptionOnLaunch_tryCatch() {
        runBlocking {
            val caught = AtomicBoolean(false)
            val job = launch(context) {
                delay(10)
                throw TestException()
            }
            try {
                job.join()
            } catch (e: TestException) {
                caught.set(true)
            } finally {
                assert(caught.get())
            }
        }
    }

    @Test
    @Ignore("not that way...")
    fun testExceptionOnLaunch_getCompletionException() {
        runBlocking {
            val job = launch(context) {
                delay(10)
                throw TestException()
            }
            try {
                job.join()
            } finally {
                val exc = job.getCompletionException()
                assert(exc is TestException)
            }
        }
    }

    @Test
    fun testExceptionOnFuture() {
        System.setProperty("kotlinx.coroutines.debug", "off")
        runBlocking {
            val caught = AtomicBoolean(false)
            val job = future(context) {
                delay(10)
                throw TestException()
            }
            try {
                job.await()
            } catch (e: TestException) {
                caught.set(true)
            } finally {
                assert(caught.get())
            }
        }
    }
}

[Zedonboy]

Honestly Kotlin seems to be a crap in the long term, more like wheel reinventing. Didn’t use beautiful features of C#, Java, just created a new way of doing everything things.

So kotlin is trying to say that, i cant handle error like the popular Promise way? example Defered.onError(//pass a lambda here),

The learning curve is fucking high, Docs didnt explain things well. all i gain is

1. Null Safety(Java is already doing well with that)
2. Concise (Still difficult to read a Kotlin Code, coming from a static typing world)
3. No Performance Gain
4. No Domain Specific Feature(like Scala in Distributed Computing)

I really want to help in the Docs, fuck coroutines. (Not really happy with this kotlin, I feeling threatened my Java was getting obsolete and wasted my time learning kotlin)

I still Love The Challenge Kotlin is giving me though, good work guys 😃

[elizarov]

You can switch to async instead of launch and use await instead of join. This way exceptions will percolated to the functions that await. I’ll keep this issue open, because there is definitely a need for a more detailed explanation in docs.