hello! question about subroutines i have this code: ```object LoggingAsyncRunner { private val ...

# server

[mplain]

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:

[mplain]

Screenshot 2022-02-19 at 15.02.27.png

[mplain]

now if I let IDEA do its thing, it makes this:

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

[mplain]

it adds coroutineScope {

[mplain]

I do not understand what's happening here, and I failed a google check, please help me

[mplain]

basically I need to write a wrapper around a suspend function

[Sam]

I would remove the CoroutineScope receiver from your job, so it's just:

job: suspend () -> Unit

[Sam]

Unless you think you need it for some reason?

[mplain]

huh

[Sam]

Generally speaking, functions should either suspend or extend CoroutineScope, but not both

[mplain]

thank you!!

[Sam]

(The fact that launch accepts a suspend CoroutineScope.() -> Unit is a bit of an oddity which I find it best to ignore 😂)

[Sam]

Here's an article which may help: https://elizarov.medium.com/explicit-concurrency-67a8e8fd9b25

[mplain]

one more question please

[mplain]

is there a practical difference between

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)
        }

and

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

[mplain]

throwing error after logging it

[mplain]

I suspect the difference might come up if I have parent coroutines and child coroutines?

[Sam]

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).

[Sam]

In your case, you're creating a new root coroutine scope for every job, and you're not installing any error handling behaviour into that scope. That means that right now, there's no practical difference between your two code examples.

[mplain]

what if i change launch to async?

[mplain]

well, basically i need to throw errors for async, or return null, or something

[mplain]

thank you very much for your help!

[Sam]

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

[Sam]

(async still cancels its parent job too, but that doesn't affect your example)