@SinceKotlin("1.3")
public fun <T> sequence(@BuilderInference block: suspend SequenceScope<T>.() -> Unit): Sequence<T> = Sequence { iterator(block) }

// 注意
@RestrictsSuspension
@SinceKotlin("1.3")
public abstract class SequenceScope<in T> internal constructor() {
    // 向迭代器中提供一個數(shù)值
    public abstract suspend fun yield(value: T)
    // 向迭代器中提供一組數(shù)值
    public abstract suspend fun yieldAll(iterator: Iterator<T>)
    // 向迭代器中提供Collection類型的一組數(shù)值
    public suspend fun yieldAll(elements: Iterable<T>) {
        if (elements is Collection && elements.isEmpty()) return
        return yieldAll(elements.iterator())
    }
    // 向迭代器中提供Sequence類型的一組數(shù)值
    public suspend fun yieldAll(sequence: Sequence<T>) = yieldAll(sequence.iterator())
}

@SinceKotlin("1.3")
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.BINARY)
public annotation class RestrictsSuspension

public interface Sequence<out T> {
    public operator fun iterator(): Iterator<T>
}

@kotlin.internal.InlineOnly
public inline fun <T> Sequence(crossinline iterator: () -> Iterator<T>): Sequence<T> = object : Sequence<T> {
    override fun iterator(): Iterator<T> = iterator()
}

@SinceKotlin("1.3")
public fun <T> iterator(@BuilderInference block: suspend SequenceScope<T>.() -> Unit): Iterator<T> {
    val iterator = SequenceBuilderIterator<T>()
    iterator.nextStep = block.createCoroutineUnintercepted(receiver = iterator, completion = iterator)
    return iterator
}

private typealias State = Int
// 沒有要發(fā)射的數(shù)據(jù)
private const val State_NotReady: State = 0
private const val State_ManyNotReady: State = 1
// 有要發(fā)射的數(shù)據(jù)
private const val State_ManyReady: State = 2
private const val State_Ready: State = 3
// 數(shù)據(jù)全部發(fā)射完畢
private const val State_Done: State = 4
// 發(fā)射過程中出錯
private const val State_Failed: State = 5

private class SequenceBuilderIterator<T> : SequenceScope<T>(), Iterator<T>, Continuation<Unit> {
    // 迭代器的狀態(tài)
    private var state = State_NotReady
    // 迭代器下一個要發(fā)送的值
    private var nextValue: T? = null
    // 用于保存yieldAll方法傳入的迭代器
    private var nextIterator: Iterator<T>? = null
    // 用于獲取下一個數(shù)據(jù)的續(xù)體
    var nextStep: Continuation<Unit>? = null
    ...
    // 空的上下文
    override val context: CoroutineContext
        get() = EmptyCoroutineContext
}

// 發(fā)射一個數(shù)據(jù)
override suspend fun yield(value: T) {
    // 保存數(shù)據(jù)到全局變量中
    nextValue = value
    // 修改狀態(tài)
    state = State_Ready
    // 掛起協(xié)程，獲取續(xù)體
    return suspendCoroutineUninterceptedOrReturn { c ->
        // 保存續(xù)體到全局變量中
        nextStep = c
        // 掛起
        COROUTINE_SUSPENDED
    }
}
// 發(fā)射多個數(shù)據(jù)
override suspend fun yieldAll(iterator: Iterator<T>) {
    // 如果迭代器沒有數(shù)據(jù)，則直接返回
    if (!iterator.hasNext()) return
    // 如果有數(shù)據(jù)，則保存到全局變量
    nextIterator = iterator
    // 修改狀態(tài)
    state = State_ManyReady
    // 掛起協(xié)程，獲取續(xù)體
    return suspendCoroutineUninterceptedOrReturn { c ->
        // 保存續(xù)體到全局變量中
        nextStep = c
        // 掛起
        COROUTINE_SUSPENDED
    }
}

override fun hasNext(): Boolean {
    // 循環(huán)
    while (true) {
        // 判斷狀態(tài)
        when (state) {
            // 剛通過yield方法發(fā)射數(shù)據(jù)
            State_NotReady -> {}
            // 剛通過yieldAll方法發(fā)射數(shù)據(jù)
            State_ManyNotReady ->
                // 如果迭代器中還有數(shù)據(jù)
                if (nextIterator!!.hasNext()) {
                    // 修改狀態(tài)，返回true
                    state = State_ManyReady
                    return true
                } else {
                    // 沒有數(shù)據(jù)，則置空，丟棄迭代器
                    nextIterator = null
                }
            // 如果序列發(fā)生器已經發(fā)射完數(shù)據(jù)，返回false
            State_Done -> return false
            // 如果有數(shù)據(jù)，則直接返回true
            State_Ready, State_ManyReady -> return true
            // 其他狀態(tài)，則拋出異常
            else -> throw exceptionalState()
        }
        // 走到這里，說明需要去獲取下一個數(shù)據(jù)
        // 修改狀態(tài)
        state = State_Failed
        // 獲取全局保存的續(xù)體
        val step = nextStep!!
        // 置空
        nextStep = null
        // 恢復序列發(fā)生器的執(zhí)行，直到遇到y(tǒng)ield方法或yieldAll方法掛起
        step.resume(Unit)
    }
}
// 異常狀態(tài)的處理
private fun exceptionalState(): Throwable = when (state) {
    State_Done -> NoSuchElementException()
    State_Failed -> IllegalStateException("Iterator has failed.")
    else -> IllegalStateException("Unexpected state of the iterator: $state")
}

override fun next(): T {
    // 判斷狀態(tài)
    when (state) {
        // 如果當前處于已經發(fā)射完數(shù)據(jù)的狀態(tài)，則判斷是否有數(shù)據(jù)
        State_NotReady, State_ManyNotReady -> return nextNotReady()
        // 如果通過yieldAll方法獲取到了數(shù)據(jù)
        State_ManyReady -> {
            // 修改狀態(tài)
            state = State_ManyNotReady
            // 通過迭代器獲取數(shù)據(jù)
            return nextIterator!!.next()
        }
        // 如果通過yield方法獲取到了數(shù)據(jù)
        State_Ready -> {
            // 修改狀態(tài)
            state = State_NotReady
            // 獲取保存的數(shù)據(jù)并進行類型轉換
            @Suppress("UNCHECKED_CAST")
            val result = nextValue as T
            // 全局變量置空
            nextValue = null
            // 返回數(shù)據(jù)
            return result
        }
        // 其他情況，則拋出異常
        else -> throw exceptionalState()
    }
}
// 如果沒有數(shù)據(jù)，則拋出異常，有數(shù)據(jù)，則返回數(shù)據(jù)
private fun nextNotReady(): T {
    if (!hasNext()) throw NoSuchElementException() else return next()
}