Approach 1

Approach 2

Interactor

viewModelScope

class MyViewModel(
    private val interactor: Interactor
): ViewModel() {
    fun getSomething() {
        interactor.fetchSomething(
            viewModelScope
        ) {
            either(::handleError, ::handleData)
        }
    }

    private fun handleData(i: Int) { /* set/update LiveData */ }
    private fun handleError(error: Error) { /* set/update LiveData */ }
}
class Interactor(private val dispatchers: ICoroutineContextProvider) {
    fun fetchSomething(
        scope: CoroutineScope,
        callback: (result: Either<Error, Int>) -> Unit = {}
    ) {
        val job = scope.async(<http://dispatchers.io|dispatchers.io>) {
            //do something heavy

            Either.Result(5)
        }

        scope.launch(dispatchers.main) {
            callback(job.await())
        }
    }
}

fun getSomething() { viewModelScope.async { interactor.fetchSomething { …. } } }

suspend fun fetchSomething(callback: (Either<Error,Int>) -> Unit = {})

class MyViewModel(
    private val interactor: Interactor
): ViewModel() {
    fun getSomething() {
        viewModelScope.launch{
            val result: Either<Error,Int> = interactor.fetchSomething()
            result.fold(::handleError, ::handleData)
        }
    }
    private fun handleData(i: Int) { /* set/update LiveData */ }
    private fun handleError(error: Error) { /* set/update LiveData */ }
}

class Interactor(private val dispatchers: ICoroutineContextProvider) {
    suspend fun fetchSomething(): Either<Error,Int> = coroutineScope {
        //do something parallel
        val intermediateResult = async { .... }
        
        //do something heavy
        ... 
        Either.Result(5)
    }
}