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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// RUN: %target-swift-frontend %s -emit-silgen > /dev/null
public protocol MyIteratorProtocol<Element> {
associatedtype Element
mutating func next() -> Element?
}
// UnsafeBufferPointer
public struct UBP<Element> {}
public protocol MySequence<Element> {
associatedtype Element
associatedtype Iterator: MyIteratorProtocol where Iterator.Element == Element
__consuming func makeIterator() -> Iterator
func _customContainsEquatableElement(
_ element: Element
) -> Bool?
func withContiguousStorageIfAvailable<R>(
_ body: (_ buffer: UBP<Element>) throws -> R
) rethrows -> R?
}
extension MySequence where Self.Iterator == Self {
public __consuming func makeIterator() -> Iterator {
return self
}
}
extension MySequence {
public func _customContainsEquatableElement(
_ element: Iterator.Element
) -> Bool? {
return nil
}
public func withContiguousStorageIfAvailable<R>(
_ body: (UBP<Element>) throws -> R
) rethrows -> R? {
return nil
}
}
public struct MyIndexingIterator<Elements: MyCollection> {
}
extension MyIndexingIterator: MyIteratorProtocol, MySequence {
public typealias Element = Elements.Element
public typealias Iterator = MyIndexingIterator<Elements>
public typealias SubSequence = MySequence<Element>
public mutating func next() -> Elements.Element? {
return nil
}
}
public struct MyDefaultIndices<Elements: MyCollection> {}
extension MyDefaultIndices: MyCollection {
public typealias Index = Elements.Index
public typealias Element = Elements.Index
public typealias Indices = MyDefaultIndices<Elements>
public typealias SubSequence = MyDefaultIndices<Elements>
public typealias Iterator = MyIndexingIterator<MyDefaultIndices<Elements>>
public __consuming func makeIterator() -> Iterator { fatalError("todo") }
}
public struct MySlice<Base: MyCollection> {
}
extension MySlice: MyCollection {
public typealias Index = Base.Index
public typealias Indices = Base.Indices
public typealias Element = Base.Element
public typealias SubSequence = MySlice<Base>
public typealias Iterator = MyIndexingIterator<MySlice<Base>>
public __consuming func makeIterator() -> Iterator { fatalError("todo") }
}
public protocol MyCollection<Element>: MySequence {
override associatedtype Element
associatedtype Index /* : Comparable */
associatedtype Iterator = MyIndexingIterator<Self>
associatedtype SubSequence: MyCollection = MySlice<Self>
where SubSequence.Index == Index,
Element == SubSequence.Element,
SubSequence.SubSequence == SubSequence
associatedtype Indices: MyCollection = MyDefaultIndices<Self>
where Indices.Element == Index,
Indices.Index == Index,
Indices.SubSequence == Indices
}
public struct MyRange<Bound> {}
extension MyRange: MySequence {
public typealias Element = Bound
public typealias Iterator = MyIndexingIterator<MyRange<Bound>>
public __consuming func makeIterator() -> Iterator { fatalError("todo") }
}
extension MyRange: MyCollection {
public typealias Index = Bound
public typealias Indices = MyRange<Bound>
public typealias SubSequence = MyRange<Bound>
}
public struct KVPair<Key, Value>: MyCollection {
public typealias Element = (key: Key, value: Value)
public typealias Index = Int
public typealias Indices = MyRange<Int>
public typealias SubSequence = MySlice<KVPair>
public typealias Iterator = MyIndexingIterator<Self>
public __consuming func makeIterator() -> Iterator { fatalError("todo") }
}
|
