AsyncExclusiveReductionsSequence.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 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, which it returns.
 /// - 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)async->Result
)->AsyncExclusiveReductionsSequence<Self,Result>{
reductions(into: initial){ result, element in
 result =awaittransform(result, element)
}
}

 /// Returns an asynchronous sequence containing the accumulated results of combining the
 /// elements of the asynchronous sequence using the given 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.
 /// - 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)async->Void
)->AsyncExclusiveReductionsSequence<Self,Result>{
AsyncExclusiveReductionsSequence(self, initial: initial, transform: transform)
}
}

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

@usableFromInline
letinitial:Element

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

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

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

@usableFromInline
varcurrent:Element?

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

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

@inlinable
publicmutatingfunc next()asyncrethrows->Element?{
guardvar result = current else{returnnil}
letvalue=tryawait iterator.next()
guardlet value = value else{
 current =nil
returnnil
}
awaittransform(&result, value)
 current = result
return result
}
}

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

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

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