Swift Sequences & Collections

How sequences & collections work in Swift

Transcript

1. Swift Sequences & Collections @greg3z
2. let array = [1, 2, 3]
3. let array = [1, 2, 3] array[7]
4. let dic = ["a": 1, "b": 2]
5. let dic = ["a": 1, "b": 2] dic["z"]
6. [] -> subscript
7. struct Array<Element> { subscript(index: Int) -> Element }
8. struct Dictionary<Key: Hashable, Value> { subscript(key: Key) -> Value? }
9. subscript(index: Int) -> Element?
10. subscript(safe index: Int) -> Element?
11. subscript(safe index: Int) -> Element? array[safe: 2]
12. extension Array { subscript(safe i: Int) -> Element? { return i >= 0 && i < count ? self[i] : nil } }
13. let array = [1, 2, 3]
14. let array = [1, 2, 3] array[safe: 7]
15. Custom collection? A type that I did myself
16. struct Section<T> { let title: String let elements: [T] }
17. struct Section<T> { let title: String let elements: [T] subscript(index: Int) -> T? { return elements[safe: index] } }
18. let cars = ["911", "Cayman", "Cayenne"] let section = Section(title: "Porsche", elements: cars)
19. let cars = ["911", "Cayman", "Cayenne"] let section = Section(title: "Porsche", elements: cars) section[1] // Optional("Cayman")
20. Sequence A type that can be iterated with a `for`...`in` loop
21. protocol SequenceType { func generate() -> GeneratorType }
22. protocol GeneratorType { func next() -> Element? }
23. struct ArrayGenerator<T>: GeneratorType { func next() -> T? { return something } }
24. struct ArrayGenerator<T>: GeneratorType { let array: [T] var currentIndex = 0 init(_ array: [T]) { self.array = array } mutating func next() -> T? { return array[safe: currentIndex++] } }
25. struct Section<T>: SequenceType { let title: String let elements: [T] func generate() -> ArrayGenerator<T> { return ArrayGenerator(elements) } }
26. var generator = section.generate() while let element = generator.next() { }
27. for element in section { }
28. var generator = section.generate() while let element = generator.next() { } for element in section { }
29. let cars = ["911", "Cayman", "Cayenne"] let section = Section(title: "Porsche", elements: cars)
30. for car in section { } // 911 // Cayman // Cayenne
31. for (index, car) in section.enumerate() { } // 0 911 // 1 Cayman // 2 Cayenne
32. section.minElement() // 911 section.maxElement() // Cayman section.sort() // ["911", "Cayenne", "Cayman"]
33. section.contains("911") // true
34. section.filter { $0.characters.count > 3 } // ["Cayman", "Cayenne"]
35. section.map { $0.characters.count } // [3, 6, 7]
36. section.reduce(0) { $0 + $1.characters.count } // 16
37. Collection A multi-pass *sequence* with addressable positions
38. protocol CollectionType : Indexable, SequenceType { }
39. protocol Indexable { var startIndex: Index { get } var endIndex: Index { get } }
40. struct Section<T>: Indexable { let title: String var elements: [T] var startIndex: Int { return 0 } var endIndex: Int { return elements.count } subscript(index: Int) -> T? { … } func generate() -> ArrayGenerator<T> { … } }
41. protocol Indexable { var startIndex: Index { get } var endIndex: Index { get } subscript(position: Index) -> Element { get } }
42. struct Section<T>: CollectionType { let title: String var elements: [T] var startIndex: Int { return 0 } var endIndex: Int { return elements.count } subscript(index: Int) -> T? { … } func generate() -> ArrayGenerator<T> { … } }
43. struct Section<T>: CollectionType { let title: String var elements: [T] var startIndex: Int { return 0 } var endIndex: Int { return elements.count } subscript(index: Int) -> T { return elements[index] } func generate() -> ArrayGenerator<T> { … } }
44. struct Section<T>: CollectionType { let title: String let elements: [T] var startIndex: Int { return 0 } var endIndex: Int { return elements.count } subscript(index: Int) -> T { return elements[index] } subscript(safe index: Int) -> T? { return elements[safe: index] } func generate() -> ArrayGenerator<T> { … } }
45. let cars = ["911", "Cayman", "Cayenne"] let section = Section(title: "Porsche", elements: cars) section.count // 3 section.first // Optional("911") section.isEmpty // false section.indexOf("Cayman") // 1
46. Epilogue So dictionaries aren’t Collections?
47. struct Dictionary<K : Hashable, V> { subscript(key: K) -> V? subscript(position: DictionaryIndex<K, V>) -> (K, V) }
48. let dic = ["a": "audi", "b": "bmw", "c": "citroen"] let index = dic.startIndex // DictionaryIndex<String, String> dic[index] // ("a", "audi") dic[index.advancedBy(1)] // ("b", "bmw") dic[index.advancedBy(3)] // Fatal error
49. Thank you! @greg3z medium.com/swift-programming