launchCatching(
    block = {
        getRandomNumber()
    },
    result = {
        println("result is $it")
    }
).invokeOnCompletion {
    it is Throwable
}

fun <T> CoroutineScope.launchCatching(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T,
    result: (result: Result<T>) -> Unit
) = launch(context, start) {
    result(
        runCatching {
            block()
        }
    )
}

fun <T> CoroutineScope.launchCatching(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T,
    onSuccess: (value: T) -> Unit,
    onFailure: (exception: Throwable) -> Unit
) = launch(context, start) {
    runCatching {
        block()
    }.fold(
        onSuccess,
        onFailure
    )
}

launch

Result<T>

sealed class Result<T>
class SuccessResult<T>(val result: T): Result<T>
class FailureResult<T>(val error: Throwable): Result<T>

suspend fun doesNotThrowAnyErrors(): Result<String> {
  return try {
    SuccessResult(mayThrowSomeError())
  } catch (e: Exception) {
    FailureResult(e)
  }
}

// Usage
suspend fun usageExample() {
  when (val computationResult = doesNotThrowAnyErrors()) {
    is SuccessResult -> println(computationResult.value)
    is FailureResult -> println("Got an error!")
  }
}