Sample implementation of ActorState with read-write separation

ActorState.kt

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.ObsoleteCoroutinesApi
import kotlinx.coroutines.channels.actor
import kotlinx.coroutines.isActive
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlin.coroutines.CoroutineContext

interface ActorState<T : Any> : CoroutineScope {
    suspend fun update(block: T.() -> Unit)
    suspend fun <R> read(block: T.() -> R): R
}

fun <T : Any> CoroutineScope.actorState(initialState: T): ActorState<T> =
    ActorStateImpl(initialState, coroutineContext)

private class ActorStateImpl<T : Any>(
    private val state: T,
    parentContext: CoroutineContext
) : ActorState<T> {
    override val coroutineContext: CoroutineContext = parentContext + Job()

    private val updatesMutex = Mutex(false)
    @ObsoleteCoroutinesApi
    private val updatesChannel = actor<T.() -> Unit> {
        while (isActive) {
            while (isActive && updatesMutex.tryLock()) {
                try {
                    receiveOrNull()?.let {
                        state.it()
                    }
                } finally {
                    updatesMutex.unlock()
                }
            }

            while (isActive && !updatesMutex.tryLock()) {
                updatesMutex.unlock()
            }
        }
    }

    @ObsoleteCoroutinesApi
    override suspend fun update(block: T.() -> Unit) =
        updatesChannel.send(block)

    override suspend fun <R> read(block: T.() -> R) =
        updatesMutex.withLock {
            state.block()
        }
}