@OptIn(ObsoleteCoroutinesApi::class)
class ActorDelegate<T>(coroutineScope: CoroutineScope, create: () -> T) {
    class Package<T, R>(val block: T.() -> R) {
        val def = CompletableDeferred<R>()
    }

    private val channel = coroutineScope.actor<Package<T, Any>> {
        val t = create()

        channel.consumeEach {
            it.def.complete(it.block(t))
        }
    }

    suspend fun <R> withContext(block: T.() -> R): R {
        val pkg = Package(block)

        channel.send((pkg as Package<T, Any>))

        val r = pkg.def.await()

        return r as R
    }
}

fun <T> CoroutineScope.actorDelegate(create: () -> T) = ActorDelegate<T>(this, create)

class CoroutineMutableList(coroutineScope: CoroutineScope) {
    private val actorDelegate = coroutineScope.actorDelegate { mutableListOf<Int>() }


    suspend fun size() = actorDelegate.withContext { size }
    suspend fun contains(element: Int) = actorDelegate.withContext { contains(element) }
    suspend fun get(element: Int) = actorDelegate.withContext { get(element) }
    suspend fun add(element: Int) = actorDelegate.withContext { add(element) }
    // rest...
}

by

operator

*fun* getValue(thisRef: Any?, property: KProperty<*>): T

suspend

actorDelegate

ActorDelegate<T>

T

Actor is more efficient than locking under load, because in this case it always has work to do and it does not have to switch to a different context at all.

suspend fun getUserData(id: Int): UserData

size()

contains()

get()

sealed interface

when

for