Everything You Ever Wanted To Know AboutSequence and Collection

Soroush Khanlou

Transcript

1. Everything You Ever Wanted To Know About Sequence and Collection Soroush Khanlou – 2017 – @khanlou Almost
2. Collection Sequence
3. BidirectionalCollection Collection Sequence
4. RandomAccessCollection BidirectionalCollection Collection Sequence
5. Sequence Collection BidirectionalCollection RandomAccessCollection
6. Sequence Collection BidirectionalCollection RandomAccessCollection RangeReplaceableCollection MutableCollection
7. Sequence Collection BidirectionalCollection RandomAccessCollection RangeReplaceableCollection MutableCollection
8. Sequence • List of elements • Can be finite or infinite • Iteration is not always repeatable
9. Sequence protocol Sequence { associatedtype Iterator: IteratorProtocol func makeIterator() -> Iterator }
10. Sequence protocol Sequence { associatedtype Iterator: IteratorProtocol func makeIterator() -> Iterator }
11. Sequence protocol Sequence { associatedtype Iterator: IteratorProtocol func makeIterator() -> Iterator }
12. IteratorProtocol protocol IteratorProtcol { associatedtype Element mutating func next() -> Element? }
13. IteratorProtocol protocol IteratorProtcol { associatedtype Element mutating func next() -> Element? }
14. IteratorProtocol protocol IteratorProtcol { associatedtype Element mutating func next() -> Element? }
15. Sequence protocol Sequence { associatedtype Iterator: IteratorProtocol func makeIterator() -> Iterator }
16. LinkedList “A” value next end let a = ["A", "B", "C"] “B” value next “C” value next
17. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end }
18. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end }
19. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end }
20. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end }
21. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end }
22. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } }
23. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
24. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
25. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
26. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
27. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
28. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
29. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
30. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
31. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
32. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> ??? { return ??? } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
33. indirect enum LinkedListNode<T> { case value(element: T, next: LinkedListNode<T>) case end } extension LinkedListNode: Sequence { func makeIterator() -> LinkedListIterator<T> { return LinkedListIterator(current: self) } } struct LinkedListIterator<T>: IteratorProtocol { var current: LinkedListNode<T> mutating func next() -> T? { switch current { case let .value(element, next): current = next return element case .end: return nil } } }
34. LinkedList “A” value next end let a = ["A", "B", "C"] “B” value next “C” value next
35. LinkedList “A” value next end “A” value next “A” value next “A” value next end “B” value next “C” value next LinkedListIterator<String> current let iterator = LinkedListIterator<String>(current: linkedList) print(iterator.next()) // => “A”
36. LinkedList “A” value next end “A” value next “A” value next “A” value next end “B” value next “C” value next LinkedListIterator<String> current let iterator = LinkedListIterator<String>(current: linkedList) print(iterator.next()) print(iterator.next()) // => “B”
37. LinkedList “A” value next end “A” value next “A” value next “A” value next end “B” value next “C” value next LinkedListIterator<String> current let iterator = LinkedListIterator<String>(current: linkedList) print(iterator.next()) print(iterator.next()) print(iterator.next()) // => “C”
38. LinkedList “A” value next end “A” value next “A” value next “A” value next end “B” value next “C” value next LinkedListIterator<String> current let iterator = LinkedListIterator<String>(current: linkedList) print(iterator.next()) print(iterator.next()) print(iterator.next()) print(iterator.next()) // => nil
39. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine
40. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine
41. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great
42. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
43. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
44. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
45. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
46. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
47. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
48. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
49. let numberOfAdmins = users.filter({ $0.isAdmin }).count // => fine let numberOfAdmins = users.count({ $0.isAdmin }) // => great extension Sequence { func count(_ shouldCount: (Iterator.Element) -> Bool) -> Int { var count = 0 for element in self { if shouldCount(element) { count += 1 } } return count } }
50. Each Pair “A” “B” “C” “D” (“A”, “B”) (“B”, “C”) (“C”, “D”)
51. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)>
52. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “D” “A” “B” “C” “D”
53. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “D” “A” “B” “C” “D”
54. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “D” “B” “C” “D”
55. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “B” “C” “D”
56. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “B” “C” “D”
57. zip(sequence, sequence.dropFirst()) // Sequence<(T, T)> “A” “B” “C” “B” “C” “D”
58. sequence.eachPair()
59. extension Sequence { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } }
60. extension Sequence { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } }
61. extension Sequence { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } } Argument type 'Self.SubSequence' does not conform to expected type 'Sequence'
62. extension Sequence where Self.SubSequence: Sequence { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } }
63. extension Sequence where Self.SubSequence: Sequence { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } } Cannot convert return expression of type 'AnySequence<(Self.Iterator.Element, Self.SubSequence.Iterator.Element)>' to return type 'AnySequence<(Self.Iterator.Element, Self.Iterator.Element)>'
64. extension Sequence where Self.SubSequence: Sequence, Self.SubSequence.Iterator.Element == Self.Iterator.Element { func eachPair() -> AnySequence<(Iterator.Element, Iterator.Element)> { return AnySequence(zip(self, self.dropFirst())) } }
65. Sequence Collection BidirectionalCollection RandomAccessCollection
66. Collection • Inherits from Sequence • Always finite • Iteration is repeatable
67. Collection protocol Collection { associatedtype Index: Comparable var startIndex: Index var endIndex: Index subscript(position: Index) -> Iterator.Element { get } func index(after index: Index) -> Index }
68. Collection protocol Collection { associatedtype Index: Comparable var startIndex: Index var endIndex: Index subscript(position: Index) -> Iterator.Element { get } func index(after index: Index) -> Index }
69. Collection protocol Collection { associatedtype Index: Comparable var startIndex: Index var endIndex: Index subscript(position: Index) -> Iterator.Element { get } func index(after index: Index) -> Index }
70. Collection protocol Collection { associatedtype Index: Comparable var startIndex: Index var endIndex: Index subscript(position: Index) -> Iterator.Element { get } func index(after index: Index) -> Index }
71. func forEach(_ block: (Element) -> Void) { var currentIndex = self.startIndex while currentIndex < self.endIndex { block(self[currentIndex]) currentIndex = self.index(after: currentIndex) } }
72. func forEach(_ block: (Element) -> Void) { var currentIndex = self.startIndex while currentIndex < self.endIndex { block(self[currentIndex]) currentIndex = self.index(after: currentIndex) } }
73. func forEach(_ block: (Element) -> Void) { var currentIndex = self.startIndex while currentIndex < self.endIndex { block(self[currentIndex]) currentIndex = self.index(after: currentIndex) } }
74. func forEach(_ block: (Element) -> Void) { var currentIndex = self.startIndex while currentIndex < self.endIndex { block(self[currentIndex]) currentIndex = self.index(after: currentIndex) } }
75. func forEach(_ block: (Element) -> Void) { var currentIndex = self.startIndex while currentIndex < self.endIndex { block(self[currentIndex]) currentIndex = self.index(after: currentIndex) } }
76. struct APIErrorCollection { fileprivate let _errors: [APIError] } errorCollection.contains({ $0.id == "error.item_already_added" }) // won’t compile
77. extension APIErrorCollection: Collection { var startIndex: Int { return _errors.startIndex } var endIndex: Int { return _errors.endIndex } func index(after index: Int) -> Int { return _errors.index(after: index) } subscript(position: Int) -> APIError { return _errors[position] } }
78. extension APIErrorCollection: Collection { var startIndex: Int { return _errors.startIndex } var endIndex: Int { return _errors.endIndex } func index(after index: Int) -> Int { return _errors.index(after: index) } subscript(position: Int) -> APIError { return _errors[position] } }
79. extension APIErrorCollection: Collection { var startIndex: Int { return _errors.startIndex } var endIndex: Int { return _errors.endIndex } func index(after index: Int) -> Int { return _errors.index(after: index) } subscript(position: Int) -> APIError { return _errors[position] } }
80. extension APIErrorCollection: Collection { var startIndex: Int { return _errors.startIndex } var endIndex: Int { return _errors.endIndex } func index(after index: Int) -> Int { return _errors.index(after: index) } subscript(position: Int) -> APIError { return _errors[position] } }
81. extension APIErrorCollection: Collection { var startIndex: Int { return _errors.startIndex } var endIndex: Int { return _errors.endIndex } func index(after index: Int) -> Int { return _errors.index(after: index) } subscript(position: Int) -> APIError { return _errors[position] } }
82. struct APIErrorCollection { fileprivate let _errors: [APIError] } extension APIErrorCollection: Collection { // ... } errorCollection.contains({ $0.id == "error.item_already_added" }) // compiles!
83. Sequence Collection BidirectionalCollection RandomAccessCollection
84. BidirectionalCollection • Inherits from Collection • Can go backwards as well as forwards
85. BidirectionalCollection protocol Collection { //... func index(after index: Index) -> Index } protocol BidirectionalCollection: Collection { func index(before index: Index) -> Index }
86. BidirectionalCollection protocol Collection { //... func index(after index: Index) -> Index } protocol BidirectionalCollection: Collection { func index(before index: Index) -> Index }
87. BidirectionalCollection var last: Iterator.Element? { guard !self.isEmpty else { return nil } let indexOfLastItem = self.index(before: self.endIndex) return self[indexOfLastItem] }
88. BidirectionalCollection var last: Iterator.Element? { guard !self.isEmpty else { return nil } let indexOfLastItem = self.index(before: self.endIndex) return self[indexOfLastItem] }
89. BidirectionalCollection var last: Iterator.Element? { guard !self.isEmpty else { return nil } let indexOfLastItem = self.index(before: self.endIndex) return self[indexOfLastItem] }
90. BidirectionalCollection var last: Iterator.Element? { guard !self.isEmpty else { return nil } let indexOfLastItem = self.index(before: self.endIndex) return self[indexOfLastItem] }
91. BidirectionalCollection extension BidirectionalCollection { func reversed() -> [Iterator.Element] { var elements: [Iterator.Element] = [] var currentIndex = self.endIndex while currentIndex > self.startIndex { currentIndex = self.index(before: currentIndex) elements.append(self[currentIndex]) } return elements } }
92. BidirectionalCollection extension BidirectionalCollection { func reversed() -> [Iterator.Element] { var elements: [Iterator.Element] = [] var currentIndex = self.endIndex while currentIndex > self.startIndex { currentIndex = self.index(before: currentIndex) elements.append(self[currentIndex]) } return elements } }
93. BidirectionalCollection extension BidirectionalCollection { func reversed() -> [Iterator.Element] { var elements: [Iterator.Element] = [] var currentIndex = self.endIndex while currentIndex > self.startIndex { currentIndex = self.index(before: currentIndex) elements.append(self[currentIndex]) } return elements } }
94. BidirectionalCollection extension BidirectionalCollection { func reversed() -> [Iterator.Element] { var elements: [Iterator.Element] = [] var currentIndex = self.endIndex while currentIndex > self.startIndex { currentIndex = self.index(before: currentIndex) elements.append(self[currentIndex]) } return elements } }
95. BidirectionalCollection extension BidirectionalCollection { func reversed() -> [Iterator.Element] { var elements: [Iterator.Element] = [] var currentIndex = self.endIndex while currentIndex > self.startIndex { currentIndex = self.index(before: currentIndex) elements.append(self[currentIndex]) } return elements } }
96. Sequence Collection BidirectionalCollection RandomAccessCollection
97. RandomAccessCollection • Contant-time (O(1)) access to all elements • No new implementation requirements, only new semantics
98. RandomAccessCollection func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
99. Strideable protocol Strideable: Comparable { func advanced(by n: Self.Stride) -> Self func distance(to other: Self) -> Self.Stride }
100. Sequence Collection BidirectionalCollection RandomAccessCollection RangeReplaceableCollection MutableCollection