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

So is there a way I can get the first version of `EventBus` to work?

Okay, the solution with `with()` works but not without. Why is that?

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.

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