代码里涉及到的知识点太多了，协程理解起来本来就困难，再糅杂一些高阶函数，操作符重载，密封类等等骚操作，确实懵逼。

简化之后其实很简单了。

import base.Log
import kotlin.coroutines.*

interface Operators {
    suspend fun eat()
    suspend fun sleep()
    suspend fun shopping()
}

class MyOperators(suspendOptions: suspend Operators.() -> Unit) : Operators, Continuation<Unit> {
    override val context = EmptyCoroutineContext
    private var value: String? = null
    private var end = false

    private var continuation: Continuation<Unit>

    init {
        continuation = suspendOptions.createCoroutine(this, this)
    }

    override suspend fun eat() = suspendCoroutine {
        continuation = it
        this.value = "eat"
    }

    override suspend fun sleep() = suspendCoroutine {
        continuation = it
        this.value = "sleep"
    }

    override suspend fun shopping() = suspendCoroutine {
        continuation = it
        this.value = "shopping"
    }

    override fun resumeWith(result: Result<Unit>) {
        end = true
        result.getOrThrow()
    }

    fun next(): String {
        return if (end) {
            "事情都做完了 没事儿干了！！！"
        } else if (value == null) {
            continuation.resume(Unit)
            next()
        } else {
            val value = this.value!!
            this.value = null
            value
        }
    }
}

fun main() {
    val suspendOptions: suspend Operators.() -> Unit = {
        eat()
        sleep()
        shopping()
        sleep()
        eat()
    }
    MyOperators(suspendOptions).apply {
        next().let(Log::d)
        next().let(Log::d)
        next().let(Log::d)
        next().let(Log::d)
        next().let(Log::d)
        next().let(Log::d)
    }

}