kotlin CoroutineScope.launchTry{}.catch{}

launchTry.kt

package com.dyguests.util

import androidx.annotation.CheckResult
import kotlinx.coroutines.CoroutineExceptionHandler
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch

/**
 * Launch a coroutine with error handling support.
 *
 * Use the returned [LaunchTryScope] to specify error handling behavior:
 * - [LaunchTryScope.catch] to handle exceptions with a custom handler.
 * - [LaunchTryScope.forget] to launch the coroutine and ignore exceptions.
 * - [LaunchTryScope.throws] to rethrow exceptions.
 *
 * @return [LaunchTryScope] for specifying error handling behavior.
 */
@CheckResult(suggest = "Use 'catch', 'forget', or 'throws' on the returned LaunchTryScope")
fun CoroutineScope.launchTry(block: suspend CoroutineScope.() -> Unit) = LaunchTryScope(this, block)

class LaunchTryScope(
    private val scope: CoroutineScope,
    private val block: suspend CoroutineScope.() -> Unit,
) {
    private var errorHandler: (Exception) -> Unit = {}

    /**
     * Specify an exception handler to be used if an exception occurs.
     *
     * @param handler The exception handler.
     * @return The [Job] representing the coroutine.
     */
    fun catch(handler: (Exception) -> Unit): Job {
        errorHandler = handler
        return launch(block)
    }

    /**
     * Launch the coroutine and ignore exceptions.
     *
     * @return The [Job] representing the coroutine.
     */
    fun forget(): Job {
        return launch(block)
    }

    /**
     * Launch the coroutine and rethrow exceptions.
     *
     * @return The [Job] representing the coroutine.
     */
    fun throws(): Job {
        errorHandler = { throw it }
        return launch(block)
    }

    private fun launch(block: suspend CoroutineScope.() -> Unit) = scope.launch(
        CoroutineExceptionHandler { _, throwable ->
            catchInternal(throwable)
        }
    ) {
        try {
            block()
        } catch (throwable: Throwable) {
            catchInternal(throwable)
        }
    }

    private fun catchInternal(throwable: Throwable) {
        if (throwable is Exception) {
            errorHandler(throwable)
        } else {
            throw throwable
        }
    }
}