En vieux bourlingueur du langage Swift, Grégoire Lhotellier viendra nous présenter les séquences et les collections du nouveau langage d’Apple. Il nous briefera sur l’essentiel de ce qu’il faut en savoir et ce qu’elles changent par rapport à leurs équivalent Objective-C.

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