A modern programming language that makes developers happier.

kotlinlang

Hello. I have a question about combining coroutines and `Result&lt;T&gt;`.

I have the code like following:

```
launch {
    runCatching { doSomething() }
        .onSuccess {
            doSuccessProcess(it)
        }
        .onFailure {
            doFailureProcess()
        }
}
```

I wanna handle errors if `doSomething()` fails.
But this code catches `CancellationException` as well when `launch` was canceled.
Are there any problems? Can I just ignore the `CancellationException`?

But what should happen in case of cancellation?

you requested for some result, cancellation means that result is not ready

oh, I see. you’re right.
I want to just ignore the result if it canceled.

btw, does it not impede the propagation of cancellations?

You can do something like this of course to ignore:
```runCatching { 
try { doSomething() } catch (e: CancellationException) { someDefault() }
}```

also, I don’t see reason in general for this usage of runBlocking with launch, you do not return any result, why not just use try/catch, so you can check exception type

`doSomething()` returns value and it may throw exceptions too.
And I can’t list up those exceptions in advance.

Not sure what you mean, I meant this:
```try {
  doSomething()
} catch(e: CancellationException) {
   //Do nothning
} catch(e: Exception) {
  doFailureProcess()
} ```

doSomething returns value, so I meant:

```
val value = try {
  doSomething()
} catch (e: CancellationException) {
  return
} catch (e: Exception) {
  doFailureProcess()
  return
}
doSuccessProcess(value)
```

Yes, try/catch style is possible, but I prefer Result&lt;T&gt; style because it is more readable than try/catch one.

My question was "CancellationException will be caught by runCatching", and you did let me notice that it is a surely exception because it was cancelled so I need handle the exception.
So the question was already solved.
I am always grateful for your help!