AsyncThrowingExclusiveReductionsSequence.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.
 ///
 /// - Parameters:
 /// - initial: The value to use as the initial value.
 /// - transform: A closure that combines the previously reduced result and
 /// the next element in the receiving asynchronous sequence and returns
 /// the result. If the closure throws an error, the sequence throws.
 /// - Returns: An asynchronous sequence of the initial value followed by the reduced
 /// elements.
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc reductions<Result>(
 _ initial:Result,
 _ transform:@Sendable@escaping(Result, Element)asyncthrows->Result
)->AsyncThrowingExclusiveReductionsSequence<Self,Result>{
reductions(into: initial){ result, element in
 result =tryawaittransform(result, element)
}
}

 /// 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.
 ///
 /// - Parameters:
 /// - initial: The value to use as the initial value.
 /// - transform: A closure that combines the previously reduced result and
 /// the next element in the receiving asynchronous sequence, mutating the
 /// previous result instead of returning a value. If the closure throws an
 /// error, the sequence throws.
 /// - Returns: An asynchronous sequence of the initial value followed by the reduced
 /// elements.
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc reductions<Result>(
 into initial:Result,
 _ transform:@Sendable@escaping(inoutResult,Element)asyncthrows->Void
)->AsyncThrowingExclusiveReductionsSequence<Self,Result>{
AsyncThrowingExclusiveReductionsSequence(self, initial: initial, transform: transform)
}
}

/// An asynchronous sequence of applying an error-throwing transform to the element of
/// an asynchronous sequence and the previously transformed result.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructAsyncThrowingExclusiveReductionsSequence<Base:AsyncSequence, Element>{
@usableFromInline
letbase:Base

@usableFromInline
letinitial:Element

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

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

@available(AsyncAlgorithms 1.0,*)
extensionAsyncThrowingExclusiveReductionsSequence:AsyncSequence{
 /// The iterator for an `AsyncThrowingExclusiveReductionsSequence` instance.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructIterator:AsyncIteratorProtocol{
@usableFromInline
variterator:Base.AsyncIterator

@usableFromInline
varcurrent:Element?

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

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

@inlinable
publicmutatingfunc next()asyncthrows->Element?{
guardvar result = current else{returnnil}
letvalue=tryawait iterator.next()
guardlet value = value else{
 current =nil
returnnil
}
do{
tryawaittransform(&result, value)
 current = result
return result
}catch{
 current =nil
throw error
}
}
}

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

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

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