A modern programming language that makes developers happier.

kotlinlang

So I know coroutine cancellation is cooperative, but I have a fairly simple case here that I'm not sure how to dig myself out of.

I essentially have a button that calls `fetchMoreData()`

```fun fetchMoreData(i) {
  viewModelScope.launch { ...```
but now if I call fetchMoreData() again, I actually want to cancel the old data fetching. How would I do that?

This is the closest thing I've been able to find, but still seems a bit lengthy and at 2 years old, I'm wondering what the idiomatic way to do this is. <https://stackoverflow.com/a/63776757>

that answer is a bad idea; that job is not parented to the viewModelScope

Save the Job returned from the `launch` and cancel it before launching.

right, that's an option:
```var fetchJob: Job? = null
fun fetch() {
    fetchJob?.cancel()
    fetchJob = viewModelScope.launch { ... }```

Nice. I was hoping for something easy peasy... but I didn't know if this kinda felt like an rx-ism and so far everything ive ever brought from rx to coroutines has been wrong. hence I wanted to check.

you could also a flow as a trigger, e.g.
```val fetchRequests = MutableSharedFlow&lt;Unit&gt;()
fun start() {
    fetchRequests.mapLatest { ... }.launchIn(viewModelScope)
}
fun fetch() {
    fetchRequests.tryEmit(Unit)
}```

<@UJQB4DJF7> for the sake of curiousotity. "right, that's an option:"

whats some other options that come to mind.

To me another option (which goes against the whole cancelling thing) would just be to treat it as a flow/queue and just finish off the current task, and then handle the next.

thanks <@UJQB4DJF7> looks like i was on the sort of same page

ah. but yeah. a flowable with *latest would just cancel the previoius.

man. flows/coroutines are so powerful. lol

Note that it's a convention for a function that launches a coroutine and returns immediately to be an extension on CoroutineScope.

&gt; If you need to launch a coroutine that keeps running after your function returns, then make your function an extension of `CoroutineScope` or pass `scope: CoroutineScope` as parameter to make your intent clear in your function signature. Do not make these functions suspending:
&gt; <https://elizarov.medium.com/coroutine-context-and-scope-c8b255d59055>