It depends on what you want

doSomething

to do: • If you want to wait until it finishes doing its work you write

suspend fun doSomething() = coroutineScope { ... }

• If you want it to return quickly with a side effect of launching new coroutine, you write

fun CoroutineScope.doSometing() = launch { ... }

.

But extensions functions are static, right? So this would not work

class EventBus {
  fun CoroutineScope.send(...) { ... }
}

// somewhere else
val eventBus = EventBus()
launch {
  eventBus.send(...)
}

No, they are not static, they are resolved statically. It's an important distinction.

So is there a way I can get the first version of

EventBus

to work?

Sure, if "somewhere else" is in a CoroutineScope, you can just use

val eventBus = EventBus()
with(eventBus) {
    send()
}

Sorry, I fixed my copy/paste error

Okay, the solution with

with()

works but not without. Why is that?

Because you need to be in the context of

EventBus

to use extension methods declared in it. It's a scoping issue, not specific to coroutines.

Okay, but still is a bit confusing because when I type

eventBus.

I thought everything after the

.

is then called in the context of

EventBus

. So I'm calling the function on the object. I wonder if this should work for extension function of the object, too?

No,

eventBus.foo()

calls

foo

on

eventBus

not in the context of

eventBus

@svenjacobs This "In the context" of works, because methods (functions) in Kotlin can have two receivers, like the

inContext

function below.

class MyClass {
    fun printValue(value :Int) {
        println("Value ${value.inContext()}")
    }

    fun Int.inContext(): String {
        return (this + 6).toString() + this@MyClass.hashCode().toString()
    }
}

fun main() {
    MyClass().printValue(4)
}

@streetsofboston Thanks, I don't think I was explaining that well at all 🙂