Hi guys, if I want to declare an interface with a ...

# coroutines

[Andrea Giuliano]

Hi guys, if I want to declare an interface with a method that runs in the scope of the caller, is that ok to do something like

interface MyGuy {
  suspend fun CoroutineScope.doSomething()
}

or is there a better way when it comes to interface declaration?

[andylamax]

I think every suspend function runs in the scope of the caller. No extension need there.

[Andrea Giuliano]

gotcha, so you go either with suspend modifier or with CoroutineScope. extension function?

[gildor]

Definitely suspend (if you don’t have some very specific use case for it)

[Andrea Giuliano]

one thing that made me suspicious is that if I have a suspend function, I can’t do launch inside.

suspend fun doSomething() {
    launch {} // not possible
}

that’s because I’m not in a scope, so how to I make launch be running in the caller scope?

[andylamax]

If all you are worried is scoping, go with suspend modifier.

as an advice, given by @elizarov use CoroutineScope extension when your are creating another coroutine. It kinda makes the code self documenting and I do agree with him there

[gildor]

It’s possible

[gildor]

just use coroutineScope function

[gildor]

suspend fun doSomething() {
    coroutineScope {
         launch {} // Possible!
    }
}

[gildor]

It also not only possible, but properly implement structure concurrency

[Andrea Giuliano]

gotcha, alright makes sense, thanks guys

[gildor]

launching background task as side effect on external scope smells a lot, better to allow run it as suspend function, so user of this API can decide it to run on any scope

[gildor]

It was also recently discussed in this thread
https://kotlinlang.slack.com/archives/C1CFAFJSK/p1597971811047400

[andylamax]

adding onto @gildor I would normally do

suspend function doSomenthing() = coroutineScope {
  launch{
    // do crazy things in here
  }
}

Just in case I need the instance of the calling scope, if not, I just call the function

[gildor]

would like to point out, this code makes sense only if you have a few things run in parallel (or one thing + join()), otherwise this method is the same as:

suspend function doSomenthing() = // do crazy things in here

[Andrea Giuliano]

makes sense, so if I want to build new coroutines starting from the calling scope, I do coroutineScope {} or else I can avoid using the scope builder and just what I need to inside the function, that will be called with the parent scope of the calling function in both cases