hello! question about subroutines i have this code:

object LoggingAsyncRunner {

    private val log: Logger = LoggerFactory.getLogger(this.javaClass)

    fun launch(job: () -> Unit) {
        CoroutineScope(Dispatchers.Default).launch {
            runHandlingErrors(job)
        }
    }

    private fun runHandlingErrors(job: () -> Unit) =
        try {
            job()
        } catch (e: IllegalArgumentException) {
            log.warn("Async job exception", e)
        } catch (e: Exception) {
            log.error("Async job exception", e)
        }
}

this cannot handle

delay

, so I change

job: () -> Unit

to

job: suspend CoroutineScope.() -> Unit

, and also add

suspend

to

fun runHandlingErrors

object LoggingAsyncRunner {

    private val log: Logger = LoggerFactory.getLogger(this.javaClass)

    fun launch(job: suspend CoroutineScope.() -> Unit) {
        CoroutineScope(Dispatchers.Default).launch {
            runHandlingErrors(job)
        }
    }

    private suspend fun runHandlingErrors(job: suspend CoroutineScope.() -> Unit) =
        try {
            job(~)
        } catch (e: IllegalArgumentException) {
            log.warn("Async job exception", e)
        } catch (e: Exception) {
            log.error("Async job exception", e)
        }
}

now I get an error in fun runHandlingErrors inside try block (marked with ~) saying:

no value passed for parameter p1

I then add CoroutineScope receiver to fun runHandlingErrors, and I get this warning:

I would remove the

CoroutineScope

receiver from your

job

, so it's just:

job: suspend () -> Unit

huh

Generally speaking, functions should either suspend or extend

CoroutineScope

, but not both

thank you!!

(The fact that

launch

accepts a

suspend CoroutineScope.() -> Unit

is a bit of an oddity which I find it best to ignore 😂)

one more question please

That's exactly right 👍. Errors which are thrown inside

launch

or

async

will propagate upwards to the parent job, until they reach the root job (which is normally a coroutine scope).

async

will return a

Deferred

which you can use to see if the job threw an exception. In that case, your first example would make it always appear successful, while the second example would ensure the

Deferred

also fails with the appropriate exception