AsyncAdjacentPairsSequence.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{
 /// An `AsyncSequence` that iterates over the adjacent pairs of the original
 /// original `AsyncSequence`.
 ///
 /// ```
 /// for await (first, second) in (1...5).async.adjacentPairs() {
 /// print("First: \(first), Second: \(second)")
 /// }
 ///
 /// // First: 1, Second: 2
 /// // First: 2, Second: 3
 /// // First: 3, Second: 4
 /// // First: 4, Second: 5
 /// ```
 ///
 /// - Returns: An `AsyncSequence` where the element is a tuple of two adjacent elements
 /// or the original `AsyncSequence`.
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc adjacentPairs()->AsyncAdjacentPairsSequence<Self>{
AsyncAdjacentPairsSequence(self)
}
}

/// An `AsyncSequence` that iterates over the adjacent pairs of the original
/// `AsyncSequence`.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructAsyncAdjacentPairsSequence<Base:AsyncSequence>:AsyncSequence{
publictypealiasElement=(Base.Element,Base.Element)

@usableFromInline
letbase:Base

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

 /// The iterator for an `AsyncAdjacentPairsSequence` instance.
@frozen
publicstructIterator:AsyncIteratorProtocol{
publictypealiasElement=(Base.Element,Base.Element)

@usableFromInline
varbase:Base.AsyncIterator

@usableFromInline
internalvarpreviousElement:Base.Element?

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

@inlinable
publicmutatingfunc next()asyncrethrows->(Base.Element,Base.Element)?{
if previousElement ==nil{
 previousElement =tryawait base.next()
}

guardlet previous = previousElement,let next =tryawait base.next()else{
returnnil
}

 previousElement = next
return(previous, next)
}
}

@inlinable
publicfunc makeAsyncIterator()->Iterator{
Iterator(base.makeAsyncIterator())
}
}

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

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