AsyncJoinedSequence.swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//

@available(AsyncAlgorithms 1.0,*)
extensionAsyncSequencewhere Element:AsyncSequence{
 /// Concatenate an `AsyncSequence` of `AsyncSequence` elements
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc joined()->AsyncJoinedSequence<Self>{
returnAsyncJoinedSequence(self)
}
}

/// An `AsyncSequence` that concatenates`AsyncSequence` elements
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstruct AsyncJoinedSequence<Base:AsyncSequence>:AsyncSequencewhere Base.Element:AsyncSequence{
publictypealiasElement=Base.Element.Element
publictypealiasAsyncIterator=Iterator

 /// The iterator for an `AsyncJoinedSequence` instance.
@frozen
publicstruct Iterator:AsyncIteratorProtocol{
@usableFromInline
enumState{
case initial(Base.AsyncIterator)
case sequence(Base.AsyncIterator,Base.Element.AsyncIterator)
case terminal
}

@usableFromInline
varstate:State

@inlinable
init(_ iterator:Base.AsyncIterator){
 state =.initial(iterator)
}

@inlinable
publicmutatingfunc next()asyncrethrows->Base.Element.Element?{
do{
 switch state {
case.terminal:
returnnil
case.initial(var outerIterator):
guardlet innerSequence =tryawait outerIterator.next()else{
 state =.terminal
returnnil
}
letinnerIterator= innerSequence.makeAsyncIterator()
 state =.sequence(outerIterator, innerIterator)
returntryawaitnext()
case.sequence(var outerIterator,var innerIterator):
iflet item =tryawait innerIterator.next(){
 state =.sequence(outerIterator, innerIterator)
return item
}

 guard let nextInner =tryawait outerIterator.next()else{
 state =.terminal
returnnil
}

 state =.sequence(outerIterator, nextInner.makeAsyncIterator())
returntryawaitnext()
}
}catch{
 state =.terminal
throw error
}
}
}

 @usableFromInline
let base: Base

 @usableFromInline
 init(_ base: Base){
self.base = base
}

 @inlinable
 public func makeAsyncIterator()-> Iterator {
returnIterator(base.makeAsyncIterator())
}
}

@available(AsyncAlgorithms 1.0,*)
extension AsyncJoinedSequence: Sendable
where Base: Sendable,Base.Element: Sendable,Base.Element.Element: Sendable {}

@available(*, unavailable)
extension AsyncJoinedSequence.Iterator: Sendable {}