consume_flow_extension.kt

sealed class HomeActions {

    class ShowPosts(val posts: List<Post>) : HomeActions()
    class ShowUsers(val users: List<User>) : HomeActions()
}

data class HomeState(val posts: List<Post> = listOf(), val user: List<User> = listOf())

private val homeActions: ConflatedBroadcastChannel<HomeActions> by lazy { ConflatedBroadcastChannel<HomeActions>() }

private val homeState: Flow<HomeState> by lazy { homeActions.asFlow().asStateMachine(
        HomeState(),
        { state, action -> when(action) {
            is HomeActions.ShowPosts -> HomeState(posts = action.posts)
            is HomeActions.ShowUsers -> HomeState(user = action.users)
            else -> state
        }}
)}

private fun observeStates() = homeState.collect {
      render(it) // <-- this part is not supported by Android, Compose comes to support it
}

private fun fetchPosts() = launch {
  val posts = withContext(Dispatchers.IO) {
    interactor.fetchPosts()
  }
  homeActions.send(HomeActions.ShowPosts(posts))
}

private fun fetchUsers() = launch {
  val users = withContext(Dispatchers.IO) {
    interactor.fetchUsers()
  }
  homeActions.send(HomeActions.ShowUsers(users))
}

state_machine.kt

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.collect

typealias Reducer<S, A> = (S, A) -> S

@ExperimentalCoroutinesApi
fun <S, A> Flow<A>.asStateMachine(
        initialState: S,
        reducer: Reducer<S, A>
): Flow<S> = flow {
    var reducers = reducer
    var state = initialState
    val mutex = Mutex()
    collect { action ->
        mutex.lock()
        state = reducers(state, action)
        mutex.unlock()
        emit(state)
    }
}