swift-async-algorithms/Sources/AsyncAlgorithms/AsyncChain3Sequence.swift at main · apple/swift-async-algorithms · GitHub

Name: swift-async-algorithms/Sources/AsyncAlgorithms/AsyncChain3Sequence.swift at main · apple/swift-async-algorithms · GitHub
Rating: 4.4 (9709 reviews)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//

/// Returns a new asynchronous sequence that iterates over the three given asynchronous sequences, one
/// followed by the other.
///
/// - Parameters:
/// - s1: The first asynchronous sequence.
/// - s2: The second asynchronous sequence.
/// - s3: The third asynchronous sequence.
/// - Returns: An asynchronous sequence that iterates first over the elements of `s1`, and
/// then over the elements of `s2`, and then over the elements of `s3`
@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc chain<Base1:AsyncSequence, Base2:AsyncSequence, Base3:AsyncSequence>(
 _ s1:Base1,
 _ s2:Base2,
 _ s3:Base3
)->AsyncChain3Sequence<Base1,Base2,Base3>{
AsyncChain3Sequence(s1, s2, s3)
}

/// A concatenation of three asynchronous sequences with the same element type.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructAsyncChain3Sequence<Base1:AsyncSequence, Base2:AsyncSequence, Base3:AsyncSequence>
where Base1.Element ==Base2.Element, Base1.Element ==Base3.Element{
@usableFromInline
letbase1:Base1

@usableFromInline
letbase2:Base2

@usableFromInline
letbase3:Base3

@usableFromInline
init(_ base1:Base1, _ base2:Base2, _ base3:Base3){
self.base1 = base1
self.base2 = base2
self.base3 = base3
}
}

@available(AsyncAlgorithms 1.0,*)
extensionAsyncChain3Sequence:AsyncSequence{
publictypealiasElement=Base1.Element

 /// The iterator for a `AsyncChain3Sequence` instance.
@available(AsyncAlgorithms 1.0,*)
@frozen
publicstructIterator:AsyncIteratorProtocol{
@usableFromInline
varbase1:Base1.AsyncIterator?

@usableFromInline
varbase2:Base2.AsyncIterator?

@usableFromInline
varbase3:Base3.AsyncIterator?

@usableFromInline
init(_ base1:Base1.AsyncIterator, _ base2:Base2.AsyncIterator, _ base3:Base3.AsyncIterator){
self.base1 = base1
self.base2 = base2
self.base3 = base3
}

@inlinable
publicmutatingfunc next()asyncrethrows->Element?{
do{
iflet value =tryawait base1?.next(){
return value
} else {
 base1 =nil
}
iflet value =tryawait base2?.next(){
return value
} else {
 base2 =nil
}
returntryawait base3?.next()
}catch{
 base1 =nil
 base2 =nil
 base3 =nil
throw error
}
}
}

@available(AsyncAlgorithms 1.0,*)
@inlinable
publicfunc makeAsyncIterator()->Iterator{
Iterator(base1.makeAsyncIterator(), base2.makeAsyncIterator(), base3.makeAsyncIterator())
}
}

@available(AsyncAlgorithms 1.0,*)
extensionAsyncChain3Sequence:Sendablewhere Base1:Sendable, Base2:Sendable, Base3:Sendable{}

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