A modern programming language that makes developers happier.

kotlinlang

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(...)
}
```

At the moment I have

```
class EventBus {
  fun send(scope: CoroutineScope, ...) { ... }
} 
```

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?

So when I'm in the context of a `CoroutineScope`, why shouldn't the compiler be able to do this

```
eventBus.send(...)
```

and pass the `CoroutineScope` as the first function argument during compile time.

No, `eventBus.foo()` calls `foo` on `eventBus` not in the context of `eventBus`

"In the context of" basically means `this` points to the thing. so in
```
with (eventBus) {
    send()
}
```
You're calling `send()` on the CoroutineScope, but the call is being made in the context of `eventBus`.

<@U0B8HSTUG> 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)
}
```

<@U72C3TBDH> Thanks, I don't think I was explaining that well at all :slightly_smiling_face: