案例：Generator 与标准库的序列生成器 案例：仿 Lua 协程实现非对称协程 API

案例：Generator 与标准库的序列生成器

package com.example.myapplication.ui

import com.example.myapplication.ui.notifications.SymCoroutine
import java.lang.IllegalStateException
import java.util.concurrent.Executor
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicReference
import kotlin.coroutines.*


sealed class Status {
   
    class Created(val continuation: Continuation<Unit>) : Status()
    class Yielded<P>(val continuation: Continuation<P>) : Status()
    class Resumed<R>(val continuation: Continuation<R>) : Status()
    object Dead : Status()
}

class Coroutine<P, R>(
    override val context: CoroutineContext = EmptyCoroutineContext,
    private val block: suspend Coroutine<P, R>.CoroutineBody.(P) -> R
) : Continuation<R> {
   

    companion object {
   
        fun <P, R> create(
            context: CoroutineContext = EmptyCoroutineContext,
            block: suspend Coroutine<P, R>.CoroutineBody.(P) -> R
        ): Coroutine<P, R> {
   
            return Coroutine(context, block)
        }
    }

    inner class CoroutineBody {
   
        var parameter: P? = null
        suspend fun yield(value: R): P = suspendCoroutine {
    continuation ->
            val previousStatus = status.getAndUpdate {
   
                when (it) {
   
                    is Status.Created -> throw IllegalStateException("Never started!")
                    is Status.Yielded<*> -> throw IllegalStateException("Already yielded!")
                    is Status.Resumed<*> -> Status.Yielded(continuation)
                    Status.Dead -> throw IllegalStateException("Already dead!")
                }
            }
            (previousStatus as? Status.Resumed<R>)?.continuation?.resume(value)