Hi there. When I want to create some immediately returning method in a class, I usually write class...

# coroutines

[bnn]

Hi there.

When I want to create some immediately returning method in a class, I usually write class in following manner.

class Foo(ctx: CoroutineContext) {
    val scope = CoroutineScope(ctx)

    fun launchSome() = scope.launch { ... }
}

Are there better ways or conventions to do that?

I wonder some possibilities such as ...

- To implement CoroutineScope ( class Foo(ctx: CoroutineContext = ... : CoroutineScope { ... } )
- To define method as CoroutineScope extension function ( fun CoroutineScope.launchSome() = launch(ctx) {...} )

Thanks.

[gildor]

I usually just pass coroutine scope in such case

[gildor]

Because it allows to stop it

[bnn]

@gildor Thanks for feedback. So, you meant like this.

class Foo(private val scope: CoroutineScope) {
  fun launchSome() = scope.launch { ... }
}

Is my understanding correct?

[Luis Munoz]

Untitled

[Luis Munoz]

having to do scope.launch seems ugly to me

[bnn]

I see. Thanks!

[gildor]

I don't like implement scope, essentially you leak your scope to outside. Sometimes it's fine, but in most cases it's unnecessary and you leak scope outside (which also can be cancelled)

[gildor]

Also, I see that launchSome is public, are you sure that you need scope in Foo? Maybe just pass it to launchSome, or, even better, just make it suspend and let user of this function decide about target scope

[gildor]

@Luis Munoz "someDispatcher" looks incorrect, because you also should cache Job somewhere and pass it to CoroutineScope, not only dispatcher, otherwise every new coroutine will have own job and it breaking structured concurrency