Optionals e o Gato de Schrödinger

Deckset and Playground of my "Optionals and the Schrödinger's Cat" Talk
Apresentação no CocoaHeads Campinas em Fevereiro de 2016

Transcript

1. CocoaHeads CPS Francesco Perrotti-Garcia
2. Optionals e o Gato de Schrödinger
3. Francesco Perrotti-Garcia iOS Developer @fpg1503
13. Optionals
14. Gato de Scrödinger
15. O que é?
16. Dois estados
17. Vivo
18. Morto
19. Incerteza do conteúdo da caixa
21. Como saber?
22. Abrindo!
23. Legal, gatos... Mas e os Optionals?
24. Optionals são uma caixa
25. Dois estados
26. Alguma coisa
27. Nada
28. É um tipo!
29. enum MyOptional { case Some case None } let nothing = MyOptional.None let something = MyOptional.Some
30. Enums com valor associado
31. enum MyOptional { case Some(Any) case None } let something = MyOptional.Some(3)
32. something.dynamicType MyOptional.Type
33. Genéricos
34. enum MyOptional<T> { case Some(T) case None } let something = MyOptional.Some(3)
35. something.dynamicType MyOptional<Int>.Type
36. let nothing = MyOptional.None Generic parameter 'T' could not be inferred
37. let nothing = MyOptional<Int>.None
38. MeuTipo? na verdade é Optional<MeuTipo>
39. Açúcar Sintático!
40. Criando
41. Criar um Optional None
42. Optional<Int>()
43. Optional<Cat>()
44. MyOptional<Cat>()
45. error: 'MyOptional<Cat>' cannot be constructed because it has no accessible initializers
46. init() { self = .None }
47. Criar um Optional Some
48. let cat = Cat()
49. let mrWhiskers = MyOptional<Cat>(cat)
50. error: argument passed to call that takes no arguments
51. init(_ some: T) { self = .Some(some) }
52. Desembrulhando
53. switch
54. switch mrWhiskers { case .Some(let cat): cat.meow() case .None: print("No cat") }
55. Patern Matching
56. if case let .Some(cat) = mrWhiskers { cat.meow() }
57. nil é uma caixa vazia
58. LiteralConvertibles
59. Coisas que podem ser criadas a partir de um literal
60. NSHipster
61. @mattt
62. Swift Literal Convertibles
63. swift/docs/Literals.rst
64. 10 protocolos
65. FloatLiteralConvertible 3.14159
66. IntegerLiteralConvertible 299792458
67. BooleanLiteralConvertible true ou false
68. ArrayLiteralConvertible ["!", """, "#", "$", "%"]
69. Set
70. let animals: Set ["!", """, "#", "$", "%"]
71. DictionaryLiteralConvertible ["YYZ": "Toronto Pearson", "DUB": "Dublin", "VCP": "Viracopos", "SFO": "San Francisco"]
72. UnicodeScalarLiteralConvertible ExtendedGraphemeClusterLiteralConvertible StringLiteralConvertibl "Hello, CocoaHeads
73. StringInterpolationConvertible "Meu gato é o \(cat.name)"
74. NilLiteralConvertible
75. Pode ser criado com um nil literal
76. extension MyOptional: NilLiteralConvertible { init(nilLiteral: ()) { self = .None } }
77. Optionals são contêineres
78. map flatMap
79. map
80. func map<U>(f: (T -> U)) -> MyOptional<U> { guard let value = self else { return .None } let mappedValue = f(value) return .Some(mappedValue) }
81. E se f throws?
82. func map<U>(f: (T throws -> U)) rethrows -> MyOptional<U> { guard let value = self else { return .None } let mappedValue = try f(value) return .Some(mappedValue) }
83. Não deve ser usado pelo efeito colateral
84. @warn_unused_result
85. @warn_unused_result func map<U>(f: (T throws -> U)) rethrows -> MyOptional<U> { guard let value = self else { return .None } let mappedValue = try f(value) return .Some(mappedValue) }
86. flatMap
87. Mapeia e achata
88. @warn_unused_result func flatMap<U>(f: (T throws -> MyOptional<U>)) rethrows -> MyOptional<U> { guard let value = self else { return .None } let mappedValue = try f(value) return mappedValue }
89. O que não conseguimos recriar?
90. Açúcar sintático
91. if let
92. Caso deve ser .Some
93. if let cat = mrWhiskers { cat.meow() }
94. Inicilaizadores Falíveis
95. NSURL
97. init?(string: String)
98. init?(name: String) { guard name == "Mozzie" else { return .None } self = Cat() }
99. nil is the only return value permitted in an initializer
100. init?(name: String) { guard name == "Mozzie" else { return nil } self = Cat() }
101. let myCat = Cat(name: "Miau")
102. myCat.dynamicType Optional<Cat>
103. Não são inicializadores do seu tipo!
104. Boas práticas
105. Piramyd of doom
106. var a: String? = "one" var b: String? = "two" var c: String? = "three"
107. if let aUnwrapped = a { if let bUnwrapped = b { if let cUnwrapped = c { println("\(aUnwrapped) - \(bUnwrapped) - \(cUnwrapped)") } } }
108. if let aUnwrapped = a, bUnwrapped = b, cUnwrapped = c { println("\(aUnwrapped) - \(bUnwrapped) - \(cUnwrapped)") }
109. if let aUnwrapped = a, bUnwrapped = b, cUnwrapped = c { println("\(aUnwrapped) - \(bUnwrapped) - \(cUnwrapped)") }
110. self?.collectionView?.indexPathsForSelectedItems()!
112. ImplicitlyUnwrappedOptionals
113. O irmão malvado do optional
115. Também é um Optional
116. Objective-C
117. IBOutlet
118. Trocar nos Outlets
119. @IBOutlet weak var tableView: UITableView!
120. @IBOutlet weak var tableView: UITableView?
121. Usar como Optional!
122. tableView?.reloadData()
123. Também funciona com coisas do ObjC!
125. EXC_BREAKPOINT
126. line: 0
127. Ponte com Objective-C
128. Opcionalidade != Nulabilidade
129. Optional é um tipo!
130. Type-safety do que pode não existir
131. Mais segurança!
132. nil é um valor!
133. Mandar mesagens para nil retorna nil
134. null pointer exception
135. nil
136. Fatal error: unexpectedly found nil while unwrapping an Optional value
137. Optionals são como caixas
138. Você não sabe o que tem dentro
139. Force unwrap Desembrulhar forçado
140. Ir contra type-safety
141. Implementações "de verdade"
142. public enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible { case None case Some(Wrapped) /// Construct a `nil` instance. public init() /// Construct a non-`nil` instance that stores `some`. public init(_ some: Wrapped) /// If `self == nil`, returns `nil`. Otherwise, returns `f(self!)`. @warn_unused_result public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U? /// Returns `nil` if `self` is nil, `f(self!)` otherwise. @warn_unused_result public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U? /// Create an instance initialized with `nil`. public init(nilLiteral: ()) } extension Optional : CustomDebugStringConvertible { /// A textual representation of `self`, suitable for debugging. public var debugDescription: String { get } }
143. /// Construct a `nil` instance. @_transparent public init() { self = .None }
144. /// Construct a non-`nil` instance that stores `some`. @_transparent public init(_ some: Wrapped) { self = .Some(some) }
145. /// Create an instance initialized with `nil`. @_transparent public init(nilLiteral: ()) { self = .None }
146. /// If `self == nil`, returns `nil`. Otherwise, returns `f(self!)`. @warn_unused_result public func map<U>(@noescape f: (Wrapped) throws -> U) rethrows -> U? { switch self { case .Some(let y): return .Some(try f(y)) case .None: return .None } }
147. /// Returns `nil` if `self` is `nil`, `f(self!)` otherwise. @warn_unused_result public func flatMap<U>(@noescape f: (Wrapped) throws -> U?) rethrows -> U? { switch self { case .Some(let y): return try f(y) case .None: return .None } }
148. Nil coalescing
149. @_transparent @warn_unused_result public func ?? <T> (optional: T?, @autoclosure defaultValue: () throws -> T) rethrows -> T { switch optional { case .Some(let value): return value case .None: return try defaultValue() } }
150. O que é @_transparent?
151. swift/docs/TransparentAttr.rst
152. Obrigado!
153. Dúvidas?
154. License · My Code: MIT · Apple's Code: Apache · Deckset: CC-BY-SA · Emoji art: supplied by Emoji One
155. Contato: @fpg1503