Why don't I use viewModelScope(Dispatchers.IO).launch{ } with Kotlin?

The Code A is Ok, so I think Code B is Ok too, but in fact Code C can be compiled, why ?

What's wrong with Code B ?

Code A

CoroutineScope(Dispatchers.IO).launch {

}

Code B

viewModelScope(Dispatchers.IO).launch{

}

Code C

viewModelScope.launch(Dispatchers.IO){

}

It’s as simple as CoroutineScope and launch are functions, and viewModelScope is a property.

• CoroutineScope() is a function that takes a CoroutineContext parameter that it will use for jobs that it launches.
• launch is a function that takes an optional CoroutineContext parameter that it will merge with its scope’s context to use in its own coroutine.
• viewModelScope is an instance of a CoroutineScope. It is not an invokeable function.

Code A ✅

Code B ❌

Code C ✅

Explanation

Code A

CoroutineScope(Dispatchers.IO).launch {

}

It works because it creates a new CoroutineScope with the Dispatchers.IO and launches a coroutine in that scope using the launch function.

Source code

Code B

viewModelScope(Dispatchers.IO).launch{

}

It does not work because viewModelScope is a property that returns a CoroutineScope tied to the lifecycle of the ViewModel. However the launch function is not a member of the CoroutineScope class, so it can not be called from viewModelScope directly.

Source code

Code C

viewModelScope.launch(Dispatchers.IO){

}

It does work because viewModelScope is a property that returns a CoroutineScope tied to the lifecycle of the ViewModel. In this code, the launch function is called on the viewModelScope object returned by the property, and the Dispatchers.IO dispatcher is passed as a parameter to the launch function.

Source code

Hope it's clear now.

In Code A , You are creating you own coroutine using CoroutineScope Builder by giving Dispatcher so that's fine as it allows you to create it your own

In Code B , you are using viewModelScope which is extension property not (not accepting any arguments) coroutine builder like CoroutineScope or GlobalScope as you can see it's source code as mentioned below

public val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope: CoroutineScope? = this.getTag(JOB_KEY)
        if (scope != null) {
            return scope
        }
        return setTagIfAbsent(
            JOB_KEY,
            CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
        )
    }

In Code C , you are using launch which is extension function of CoroutineScope and accepting arguments as mentioned in source code

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}