Optional є одним з фундаментальних типів у Swift. На жаль, незважаючи на його поширеність, чимало розробників не звертають уваги на можливості, приховані у цьому типі, або використовують його недоречно. Все це призводить до порушень основних принципів програмування, а також нехтує деякими потужними можливостями, доступними у Swift. Крім того, цей тип дозволяє розглянути важливі концепти, які зроблять рутинну роботу з Optional і схожими типами, ефективнішою та зручнішою. Під час доповіді ми відповімо на питання чому та як слід оминати optional binding. Розглянемо приклад з код-рев'ю і зробимо рефакторинг у фунціональному стилі щоб побачити недоліки та переваги такого підходу у Swift. Це надасть нам змогу дослідити як Optional впливає на DI та обробку помилок і які є альтернативи до стандартних технік, доступних у Swift. http://uamobile.org/uk/topics/optional-tips-and-tricks

1. Optional
tips and tricks
Anatoly Tukhtarov, iOS Developer at Ciklum Digital

2. What this talk is not

3. What this talk is not
• “How to draw an owl?” talk

4. What this talk is not
• “How to draw an owl?” talk
• The single way to develop software

5. What this talk is not
• “How to draw an owl?” talk
• The single way to develop software
• “How we improved everything” talk

6. Agenda

7. Agenda
• Optional and optional binding

8. Agenda
• Optional and optional binding
• Error handling

9. Agenda
• Optional and optional binding
• Error handling
• DI patterns in Swift

10. Agenda
• Optional and optional binding
• Error handling
• DI patterns in Swift
• One more thing…

11. What is Optional?
enum Optional<Wrapped> {
/// The absence of a value
case none
/// The presence of a value
case some(Wrapped)
...
}

12. What is Optional?

13. • Optional is a container type
What is Optional?

14. • Optional is a container type
What is Optional?
Int

15. • Optional is a container type
What is Optional?
Int

16. • Optional is a container type
What is Optional?
Int
Int?

17. • Optional is a container type
What is Optional?
Int
Int?
.some

18. • Optional is a container type
What is Optional?
Int
Int?
.some .none

19. Optional binding

20. func generate(from string: String,
Optional binding

21. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
Optional binding

22. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
Optional binding

23. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
Optional binding

24. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
Optional binding

25. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
Optional binding

26. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
Optional binding

27. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
let transform = scaleTransform(from:…to:…)
Optional binding

28. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: image.transformed(by: transform))
Optional binding

29. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: image.transformed(by: transform))
}
Optional binding

30. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: image.transformed(by: transform))
}
Optional binding

31. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
guard let filter = CIFilter(name: "CIQRCodeGenerator")
else { return nil }
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
guard let image = filter.outputImage else { return nil }
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: image.transformed(by: transform))
}
Optional binding

32. Optional binding
Filter?

33. Optional binding
Filter?

34. Optional binding
.none
Filter?

35. Optional binding
CIF*
.some .none
Filter?
*CIFilter

36. CIF
.some .none
Filter?
Optional binding

37. CIF
.some .none
Filter?
Optional binding
CIF

38. CIF
.some .none
Filter?
.setValue
Optional binding
CIF

39. CIF
.some .none
Filter?
.setValue
Optional binding
CIF

40. CIF
.some .none
Filter?
.setValue
Optional binding
CIF
CIF

41. CIF
.some .none
Filter?
.setValue
Optional binding
.outputImage
CIF
CIF

42. CIF
.some .none
Filter?
.setValue
Optional binding
.outputImage
CIF
CIF
.some
.none
CII

43. UIImage(ciImage: )
CIF
.some .none
Filter?
.setValue
Optional binding
.outputImage
CIF
CIF
.some
.none
CII

44. These are not bindings,
these are
conditional statements

45. Deep dive

46. Deep dive
• Initializers

47. Deep dive
• Initializers
• map(_:)

48. Deep dive
• Initializers
• map(_:)
• flatMap(_:)

49. func map<U>(_ transform:
(Wrapped) throws -> U)
rethrows -> U?
map(_:)

51. func flatMap<U>(_ transform:
(Wrapped) throws -> U?)
rethrows -> U?
flatMap(_:)

54. Functional Optional

55. func generate(from string: String,
Functional Optional

56. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
Functional Optional

57. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
Functional Optional

58. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
Functional Optional

59. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
Functional Optional

60. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
Functional Optional

61. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
}.map {
Functional Optional

62. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
}.map {
let transform = scaleTransform(from:…to:…)
Functional Optional

63. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
}.map {
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: $0.transformed(by: transform))
Functional Optional

64. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
}.map {
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: $0.transformed(by: transform))
}
Functional Optional

65. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator").flatMap {
$0.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return $0.outputImage
}.map {
let transform = scaleTransform(from:…to:…)
return UIImage(ciImage: $0.transformed(by: transform))
}
}
Functional Optional

66. Functional Optional

67. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}

68. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

69. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

70. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

71. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

72. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
.flatMap { codeImage(from: string, filter: $0) }
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

73. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
.flatMap { codeImage(from: string, filter: $0) }
.map { image(form: $0, scaledTo: requestedSize) }
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

74. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
.flatMap { codeImage(from: string, filter: $0) }
.map { image(form: $0, scaledTo: requestedSize) }
}
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

75. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
.flatMap { codeImage(from: string, filter: $0) }
.map { image(form: $0, scaledTo: requestedSize) }
}
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

76. Functional Optional
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage {
let transform = scaleTransform(from: image.extent.size, to: size)
return UIImage(ciImage: image.transformed(by: transform))
}
func generate(from string: String, size
requestedSize: CGSize) -> UIImage? {
return CIFilter(name: "CIQRCodeGenerator")
.flatMap { codeImage(from: string, filter: $0) }
.map { image(form: $0, scaledTo: requestedSize) }
}
func codeImage(from string: String,
filter: CIFilter) -> CIImage? {
filter.setValue(string.data(using: .ascii),
forKey: "inputMessage")
return filter.outputImage
}

77. codeImage

78. image(. , size:)codeImage
map
CIImg
.some

79. image( , size:)codeImage
map
CIImg
.some

80. image( , size:)codeImage
map
.none
CIImg
.some

81. CIFilter()

82. CIFilter()
flatMap
codeImage( )CIF
.some

83. CIFilter()
flatMap
codeImage( )CIF
.some
.none

84. What is Optional?

85. What is Optional?
• Optional is container for a reason: it preserves optional
context

86. What is Optional?
• Optional is container for a reason: it preserves optional
context
• Optional ensures that null values aren’t passed as
arguments to functions that can’t handle them

87. What is Optional?
• Optional is container for a reason: it preserves optional
context
• Optional ensures that null values aren’t passed as
arguments to functions that can’t handle them
• Optional interface provides a handful mechanism for
applying functions to such values in a pipeline

88. What is Optional?
• Optional is container for a reason: it preserves optional
context
• Optional ensures that null values aren’t passed as
arguments to functions that can’t handle them
• Optional interface provides a handful mechanism for
applying functions to such values in a pipeline
• Optional binding applies a function to a value stored in an
Optional, not binds the value to a variable

89. Optional context

90. Optional context
• The absence of a value is OK, not an error

91. Optional context
• The absence of a value is OK, not an error
• One doesn’t care why Optional computation’s value is
absent

92. Optional context
• The absence of a value is OK, not an error
• One doesn’t care why Optional computation’s value is
absent
• Optional isn’t designed for error handling

93. Speaking about
error handling

94. Error handling

95. Error handling
• It’s better to handle errors or they will handle you

96. Error handling
• It’s better to handle errors or they will handle you
• try-catch is the default technique and can be
improved

97. Error handling
• It’s better to handle errors or they will handle you
• try-catch is the default technique and can be
improved
• Please, don’t use Optional for error handling

98. Why?

99. Why?
Optional doesn’t explain why
computation fails or interrupts

100. Error handling

101. Error handling
protocol Storage {
associatedtype Value
func fetch() -> Value?
}

102. Error handling
protocol Storage {
associatedtype Value
func fetch() -> Value?
}

103. Error handling

104. Error handling
protocol Storage {
associatedtype Value
func fetch() throws -> Value
}

105. Error handling

106. Error handling
struct PersistentStorage<T>: Storage {
typealias Value = T
func fetch() throws -> T { ... }
}

107. Error handling
struct PersistentStorage<T>: Storage {
typealias Value = T
func fetch() throws -> T { ... }
}
enum PersistentStorageError: Error {
case empty
case corruptedData
case file(error: NSError)
}

108. Error handling

109. Error handling
protocol ErrorHandling {
associatedtype ErrorType: Error
func handle(error: ErrorType)
}

110. Error handling
protocol ErrorHandling {
associatedtype ErrorType: Error
func handle(error: ErrorType)
}
struct PersistentStorageErrorHandler: ErrorHandling {
typealias ErrorType = PersistentStorageError
func handle(error: PersistentStorageError) { ... }
}

111. Error handling

112. do {
Error handling

113. do {
let cities = try citiesStorage.fetch()
Error handling

114. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
Error handling

115. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
Error handling

116. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
Error handling

117. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
Error handling

118. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
} catch is PersistentStorageError.file(let fileError) {
Error handling

119. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
} catch is PersistentStorageError.file(let fileError) {
errorHandler.handle(.file(error: fileError))
Error handling

120. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
} catch is PersistentStorageError.file(let fileError) {
errorHandler.handle(.file(error: fileError))
}
Error handling

121. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
} catch is PersistentStorageError.file(let fileError) {
errorHandler.handle(.file(error: fileError))
}
Error handling

122. do {
let cities = try citiesStorage.fetch()
} catch is PersistentStorageError.empty {
errorHandler.handle(.empty)
} catch is PersistentStorageError.corruptedData {
errorHandler.handle(.corruptedData)
} catch is PersistentStorageError.file(let fileError) {
errorHandler.handle(.file(error: fileError))
}
Error handling
DRY?

123. Error handling

124. Error handling
do {
let cities = try citiesStorage.fetch()
} catch {
(error as? PersistentStorageError)
.map(errorHandler.handle)
}

125. Error handling
do {
let cities = try citiesStorage.fetch()
} catch {
(error as? PersistentStorageError)
.map(errorHandler.handle)
}

126. Error handling
do {
let cities = try citiesStorage.fetch()
} catch {
(error as? PersistentStorageError)
.map(errorHandler.handle)
}
TYPE
CAST?

127. What if we had
Optional
with .error case
instead of .none?

129. Result<Value, Error>

130. Result<Value, Error>
*standard type since Swift 5

131. What is Result?
enum Result<Success, Error> {
/// A success, storing `Success`
case success(Success)
/// A failure, storing `Error`
case failure(Error)
...
}
apple/swift-evolution

132. Error handling

133. Error handling
protocol Storage {
associatedtype Value
associatedtype Error
func fetch() -> Result<Value, Error>
}

134. Error handling

135. Error handling
let result = citiesStorage.fetch()

136. Error handling
result.mapError(errorHandler.handle)
let result = citiesStorage.fetch()

137. Error handling (async)

138. Error handling (async)
• Reactive/promise primitives are preferable over closures*

139. Error handling (async)
• Reactive/promise primitives are preferable over closures*
* beware the memory management

140. Error handling (async)
• Reactive/promise primitives are preferable over closures*
• Allow you to chain multiple async operations in a pipeline
* beware the memory management

141. Error handling (async)
• Reactive/promise primitives are preferable over closures*
• Allow you to chain multiple async operations in a pipeline
• ReactiveSwift has typed errors in primitives
* beware the memory management

142. Why not to throw?

143. Why not to throw?
• Forces boilerplate code

144. Why not to throw?
• Forces boilerplate code
• Opposes DRY

145. Why not to throw?
• Forces boilerplate code
• Opposes DRY
• Forces type casting

146. And now for something
completely different

147. Dependency injection

148. Dependency injection
• Introduces modularity

149. Dependency injection
• Introduces modularity
• Allows components to stay loosely-coupled

150. Dependency injection
• Introduces modularity
• Allows components to stay loosely-coupled
• There’re several injection patterns

151. Injection patterns

152. Injection patterns
• Initializer injection

153. Injection patterns
• Initializer injection
• Property injection

154. Injection patterns
• Initializer injection
• Property injection
• Method injection

155. Initializer injection

156. Initializer injection
protocol Animal { ... }
struct PetOwner {
let pet: Animal
init(pet: Animal) {
self.pet = pet
}
...
}

157. Initializer injection
protocol Animal { ... }
struct PetOwner {
let pet: Animal
init(pet: Animal) {
self.pet = pet
}
...
}

158. Initializer injection

159. Initializer injection
• In Swift a type must be completely initialized before
being used

160. Initializer injection
• In Swift a type must be completely initialized before
being used
• Can’t be used with UIKit objects initialized from a xib or
a storyboard…

161. Initializer injection
• In Swift a type must be completely initialized before
being used
• Can’t be used with UIKit objects initialized from a xib or
a storyboard…
• Avoid injections in UIViewController

162. Initializer injection
• In Swift a type must be completely initialized before
being used
• Can’t be used with UIKit objects initialized from a xib or
a storyboard…
• Avoid injections in UIViewController
• UIViewController is a view, not a controller*
*Swift Heroes 2018.
Krzysztof Zablocki — Maintainable iOS Architectures

163. Initializer injection

164. Initializer injection
• Some types might have a lot of dependencies

165. Initializer injection
• Some types might have a lot of dependencies
• Try to use protocol composition in order to avoid large
initializers*
*Krzysztof Zablocki — Using protocol compositon
for dependency injection

166. Property injection

167. Property injection
protocol Animal { ... }
struct Cat: Animal { ... }
struct PetOwner {
var pet: Animal?
...
}
var person = PetOwner()
person.pet = Cat()

168. Property injection
protocol Animal { ... }
struct Cat: Animal { ... }
struct PetOwner {
var pet: Animal?
...
}
var person = PetOwner()
person.pet = Cat()

169. Property injection

170. Property injection
• Introduces Optional in a client

171. Property injection
• Introduces Optional in a client
• Forces optional binding all over the client

172. Property injection
• Introduces Optional in a client
• Forces optional binding all over the client
• Avoid implicitly unwrapped Optional if you forced to use
property injection

173. Property injection
• Introduces Optional in a client
• Forces optional binding all over the client
• Avoid implicitly unwrapped Optional if you forced to use
property injection
• Implicitly unwrapped Optional is a code smell in pure
Swift

174. Method injection

175. Method injection
protocol Animal { ... }
protocol AnimalSanctuary {
associatedtype Pet: Animal
func adopt(pet: Pet)
...
}

176. Method injection
protocol Animal { ... }
protocol AnimalSanctuary {
associatedtype Pet: Animal
func adopt(pet: Pet)
...
}

177. Method injection
protocol Animal { ... }
protocol AnimalSanctuary {
associatedtype Pet: Animal
func adopt(pet: Pet)
...
}

178. Method injection

179. Method injection
• Don’t assign injected dependency as a client’s property

180. Method injection
• Don’t assign injected dependency as a client’s property
• Suitable for simple computations over injected type

181. Injection patterns

182. Injection patterns
• Initializer injection is a default pattern in Swift

183. Injection patterns
• Initializer injection is a default pattern in Swift
• Try to avoid property injection

184. Injection patterns
• Initializer injection is a default pattern in Swift
• Try to avoid property injection
• If a project has both Swift and Objective-C code try to
annotate Nullability in Objective-C types

185. One more thing…

186. Optional is
a Monad

187. Monad

188. Monad
• Is a design pattern (data type in pure functional
languages)

189. Monad
• Is a design pattern (data type in pure functional
languages)
• Is extremely abstract and generic

190. Monad
• Is a design pattern (data type in pure functional
languages)
• Is extremely abstract and generic
• Defined by mathematical laws

191. Monad
• Is a design pattern (data type in pure functional
languages)
• Is extremely abstract and generic
• Defined by mathematical laws
• Due to high abstraction level it’s pretty complex to explain
what a monad is

192. Monad as a container

193. Monad as a container
• Encapsulates a data type

194. Monad as a container
• Encapsulates a data type
• Preserves specific context of computation

195. Monad as a container
• Encapsulates a data type
• Preserves specific context of computation
• Knows how to combine (bind) same containers together

196. Perform impure, sequenced
computations in pure
composite way
Why monad?

197. How to use monads?

198. How to use monads?
• Functions! Lots of them

199. How to use monads?
• Functions! Lots of them
• Clear, robust API

200. How to use monads?
• Functions! Lots of them
• Clear, robust API
• Rich generic support

201. How to use monads?
• Functions! Lots of them
• Clear, robust API
• Rich generic support

202. Monad API

203. Monad API
• Clear

204. Monad API
• Clear
• Composite

205. Monad API
• Clear
• Composite
• Easy to read

206. Monad API
• Clear
• Composite
• Easy to read
• Generic

207. Monad API
• Clear
• Composite
• Easy to read
• Generic
• Swift doesn’t have one by default

208. Monad API
• Clear
• Composite
• Easy to read
• Generic
• Swift doesn’t have one by default
• Let’s implement our own!

209. Optional eDSL

210. Optional eDSL
• Protocols with associated types aren’t polymorphic

211. Optional eDSL
• Protocols with associated types aren’t polymorphic
• Custom operators

212. Optional eDSL
• Protocols with associated types aren’t polymorphic
• Custom operators
• Currying and partial application

213. Optional eDSL
• Protocols with associated types aren’t polymorphic
• Custom operators
• Currying and partial application
• Function composition

214. apply operator
precedencegroup ApplicativePrecedence {
associativity: left
higherThan: NilCoalescingPrecedence
}
infix operator <*>: ApplicativePrecedence
func <*><A, B>(_ transform: ((A) -> B)?,
arg: A?) -> B? {
return transform.flatMap { arg.map($0) }
}

215. apply operator
precedencegroup ApplicativePrecedence {
associativity: left
higherThan: NilCoalescingPrecedence
}
infix operator <*>: ApplicativePrecedence
func <*><A, B>(_ transform: ((A) -> B)?,
arg: A?) -> B? {
return transform.flatMap { arg.map($0) }
}

216. precedencegroup BindingPrecedence {
associativity: left
higherThan: ApplicativePrecedence
}
infix operator |>>: BindingPrecedence
func |>><A, B>(_ transform: ((A) -> B?)?,
arg: A?) -> B? {
return transform
.flatMap { arg.flatMap($0) }
}
bind operator

217. precedencegroup BindingPrecedence {
associativity: left
higherThan: ApplicativePrecedence
}
infix operator |>>: BindingPrecedence
func |>><A, B>(_ transform: ((A) -> B?)?,
arg: A?) -> B? {
return transform
.flatMap { arg.flatMap($0) }
}
bind operator

218. But how can one pass
a function with multiple
arguments to operators?

219. Currying

220. Currying
Translates evaluation of a function
with multiple arguments into
evaluation a sequence of multiple
functions with a single argument

222. Currying
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage
{
...
}

223. Currying
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage
{
...
}
let img = image(form: ciImage,
scaledTo: requestedSize)

224. Currying
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage
{
...
}

225. Currying
func image(form image: CIImage,
scaledTo size: CGSize) -> UIImage
{
...
}

226. Currying
func image(CIImage, CGSize) -> UIImage {
...
}

227. Currying
func image(CIImage, CGSize) -> UIImage {
...
}

228. Currying
(CIImage, CGSize) -> UIImage

229. (A, B) -> C
Currying

230. (A) -> (B) -> C
Currying

231. curry
func curry<A, B, C>(_ function:
@escaping (A, B) -> C) -> (A) -> (B) -> C {
return { argA in { argB in
function(argA, argB) }
}
}

232. Currying
let img = image(form: ciImage,
scaledTo: requestedSize)

233. Currying
let img = curry(image)(ciImage)(requestedSize)

234. Currying
let img = curry(image)(ciImage)(requestedSize)

235. At this moment you’ve gotta
ask yourself a question:
What’s img type?

236. Go ahead, make my day

237. Go ahead, make my day
(CGSize) -> UIImage

238. Partial application

239. Partial application
* the statement is only true for functional languages like Haskell.
Partial application is a bit complex :)

240. Partial application
Supplying fewer than the total
number of arguments in a curried
function is referred to as partial
application*
* the statement is only true for functional languages like Haskell.
Partial application is a bit complex :)

241. Optional functions
• Performing partial application of a function using our
optional operators returns an optional function

242. Optional functions
• Performing partial application of a function using our
optional operators returns an optional function
ciImage <*> curry(image)

243. Optional functions
And the type is…
((CGSize) -> UIImage)?

244. Pure functions

245. Pure functions
• static only (memory management)

246. Pure functions
• static only (memory management)
• Use structures (immutability)

247. func generate(from string: String,
size requestedSize: CGSize) -> UIImage? {
return curry(image)
<*> curry(codeImage)
|>> CIFilter(name: "CIQRCodeGenerator")
|>> string
<*> requestedSize
}
Functional Optional

248. infix operator <^>: ApplicativePrecedence
func <^><A, B>(_ transform: (A) -> B,
arg: A?) -> B? {
return arg.map(transform)
}
map operator

249. let a: Int? = 5
let b: Int? = nil
let sum = curry(+) <^> a <*> b
let product = curry(*) <^> a <*> b
Functional Optional

250. Code sample
swordfishyou/mSwift

251. More monads?

252. More monads?
• Array (nondetermenism)

253. More monads?
• Array (nondetermenism)
• Result (error handling)

254. More monads?
• Array (nondetermenism)
• Result (error handling)
• Some Reactive primitives (concurrency)

255. But wait…

256. But wait…
• Functional style allows to stay DRY

257. But wait…
• Functional style allows to stay DRY
• Swift’s type system doesn’t allow generic monads

258. But wait…
• Functional style allows to stay DRY
• Swift’s type system doesn’t allow generic monads
• Each monad needs its own implementation of eDSL

259. But wait…
• Functional style allows to stay DRY
• Swift’s type system doesn’t allow generic monads
• Each monad needs its own implementation of eDSL
• …

260. But wait…
• Functional style allows to stay DRY
• Swift’s type system doesn’t allow generic monads
• Each monad needs its own implementation of eDSL
• …
• PROFIT!!11

261. But why?

262. But why?
• Introduces new powerful tools

263. But why?
• Introduces new powerful tools
• Encourages modularity and composition

264. But why?
• Introduces new powerful tools
• Encourages modularity and composition
• Encourages careful treatment of types and mutable
states

265. But why?
• Introduces new powerful tools
• Encourages modularity and composition
• Encourages careful treatment of types and mutable
states
• Fun!

266. Next steps

267. Next steps
• Functional Swift

268. Next steps
• Functional Swift
• Learn You a Haskell for a Greater Good

269. Next steps
• Functional Swift
• Learn You a Haskell for a Greater Good
• Haskell Wiki

270. Deep cuts

271. Deep cuts
• Jeremy Gibbons, Oege de Moor; The Fun of
Programming (ISBN: 978-0333992852)

272. Deep cuts
• Jeremy Gibbons, Oege de Moor; The Fun of
Programming (ISBN: 978-0333992852)
• Harold Abelson, Gerald Jay Sussman, Julie Sussman;
Structure and Interpretation of Computer Programs
(ISBN: 978-0262510875)

273. Thank you!
/tukhtarov anvitu@gmail.com @anatolytukhtarov