AsyncThrowingInclusiveReductionsSequence.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,*)
extensionAsyncSequence{
 /// Returns an asynchronous sequence containing the accumulated results of combining the
 /// elements of the asynchronous sequence using the given error-throwing closure.
 ///
 /// This can be seen as applying the reduce function to each element and
 /// providing the initial value followed by these results as an asynchronous sequence.
 ///
 /// ```
 /// let runningTotal = [1, 2, 3, 4].async.reductions(+)
 /// print(await Array(runningTotal))
 ///
 /// // prints [1, 3, 6, 10]
 /// ```
 ///
 /// - Parameter transform: A closure that combines the previously reduced
 /// result and the next element in the receiving sequence. If the closure
 /// throws an error, the sequence throws.
 /// - Returns: An asynchronous sequence of the reduced elements.
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc reductions(
 _ transform:@Sendable@escaping(Element, Element)asyncthrows->Element
)->AsyncThrowingInclusiveReductionsSequence<Self>{
AsyncThrowingInclusiveReductionsSequence(self, transform: transform)
}
}

/// An asynchronous sequence containing the accumulated results of combining the
/// elements of the asynchronous sequence using a given error-throwing closure.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructAsyncThrowingInclusiveReductionsSequence<Base:AsyncSequence>{
@usableFromInline
letbase:Base

@usableFromInline
lettransform:@Sendable(Base.Element,Base.Element)asyncthrows->Base.Element

@inlinable
init(_ base:Base, transform:@Sendable@escaping(Base.Element,Base.Element)asyncthrows->Base.Element){
self.base = base
self.transform = transform
}
}

@available(AsyncAlgorithms 1.0,*)
extensionAsyncThrowingInclusiveReductionsSequence:AsyncSequence{
publictypealiasElement=Base.Element

 /// The iterator for an `AsyncThrowingInclusiveReductionsSequence` instance.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructIterator:AsyncIteratorProtocol{
@usableFromInline
internalvariterator:Base.AsyncIterator?

@usableFromInline
internalvarelement:Base.Element?

@usableFromInline
internallettransform:@Sendable(Base.Element,Base.Element)asyncthrows->Base.Element

@inlinable
init(
 _ iterator:Base.AsyncIterator,
 transform:@Sendable@escaping(Base.Element,Base.Element)asyncthrows->Base.Element
){
self.iterator = iterator
self.transform = transform
}

@inlinable
publicmutatingfunc next()asyncthrows->Base.Element?{
guardlet previous = element else{
 element =tryawait iterator?.next()
return element
}
guardlet next =tryawait iterator?.next()else{returnnil}
do{
 element =tryawaittransform(previous, next)
}catch{
 iterator =nil
throw error
}
return element
}
}

@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc makeAsyncIterator()->Iterator{
Iterator(base.makeAsyncIterator(), transform: transform)
}
}

@available(AsyncAlgorithms 1.0,*)
extensionAsyncThrowingInclusiveReductionsSequence:Sendablewhere Base:Sendable{}

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