Al Skipp | The Monad Among Us

Presented at www.swiftsummit.com

Transcript

1. The Monad Among Us Al Skipp
2. The Soft Fuzzy Thing Among Us Al Skipp
3. ‘In Swift, nil is a
 polymorphic superhero’ Chris Lattner (probably)
4. Name that nil in one What is the Type of nil?
5. Name that nil in one (A wild guess — is it an Optional?) enum Optional<T> { case None case Some(T) }
6. Name that nil in one (a gentle start) let x:Bool? = nil ???
7. Name that nil in one (a gentle start) let x:Bool? = nil let x = Optional<Bool>.None
8. Name that nil in one "9".toInt() != nil ???
9. Name that nil in one "9".toInt() != nil “9".toInt() != Optional<Int>.None
10. map(nil) { $0 + "!" } Name that nil in one (Type inference required) ???
11. Name that nil in one (Type inference required) map(nil) { $0 + "!" } map(Optional<String>.None) { $0 + "!" }
12. Name that nil in one (that’s easy) nil < 0 ???
13. Name that nil in one (hmmm?) nil < 0 ??? Int (Yes?)
14. Name that nil in one (Eh!?) nil < 0 Optional<Int>.None < Optional<Int>.Some(0)
15. protocol NilLiteralConvertible { init(nilLiteral: ()) } enum Optional<T> : NilLiteralConvertible { init(nilLiteral: ()) { self = None } } How to get an Optional from ‘nil’
16. nil is a phantom The advantage of Optionals is not what they add to the language, but what they enable to be removed: nil
17. Escape from the land of the nils In many languages nil roams free and you must take precautions to remain safe
18. Mandatory, ridiculous code example let dict = [1:[2:[3:[4:[5:"Hello"]]]]]
19. let dict = [1:[2:[3:[4:[5:"Hello"]]]]] let v = dict[1][2][3][4][5] A language with nil You've gotta ask yourself one question: “Do I feel lucky?”
20. Well, do ya, punk? … (Yep) let dict = [1:[2:[3:[4:[5:"Hello"]]]]] let v = dict[1][2][3][4][5] Possible results: 1. v == "Hello"
21. let dict = [1:[2:[3:[4:[5:"Hello"]]]]] let v = dict[1][2][3][4][0] Possible results: 1. v == "Hello" 2. v == nil Well, do ya, punk? … (Not sure?)
22. let dict = [1:[2:[3:[4:[5:"Hello"]]]]] let v = dict[1][0][3][4][5] Possible results: 1. v == "Hello" 2. v == nil 3. Boom!!! Well, do ya, punk? … (Argh!)
23. Swift Dictionary subscripting struct Dictionary<Key:Hashable, Value> { subscript (key: Key) -> Value? } return value is Optional
24. Optionals are simple enum Optional<T> { case None case Some(T) }
25. Swift style (Houston, we've got a problem) let dict = [1:[2:[3:[4:[5:"Hello"]]]]] let a:String? ! switch dict[1] { case .None : a = .None case .Some(let d) : switch d[2] { case .None : a = .None case .Some(let d) : switch d[3] { case .None : a = .None case .Some(let d) : switch d[4] { case .None : a = .None case .Some(let d) : switch d[5] { case .None : a = .None case .Some(let x) : a = x } } } } }
26. Swift style (safe, yet insane) let a:String? ! switch dict[1] { case .None : a = .None case .Some(let d) : switch d[2] { case .None : a = .None case .Some(let d) : switch d[3] { case .None : a = .None case .Some(let d) : switch d[4] { case .None : a = .None case .Some(let d) : switch d[5] { case .None : a = .None case .Some(let x) : a = x } } } } }
27. What did Optional chaining ever do for us? let v = dict[1]?[2]?[3]?[4]?[5]
28. let v = dict[1]?[2]?[3]?[4]?[5] Monadic bind What did Optional chaining ever do for us?
29. You probably won’t break a leg Optionals are the ‘green piste’ on the monadic mountain
30. >>= No! Not the custom infix operator!
31. infix operator >>= {associativity left} Declaration of a custom infix operator
32. func >>= <A,B>(x: A?, f: A -> B?) -> B? Monadic bind for Optionals
33. func >>= <A,B>(x: A?, f: A -> B?) -> B? Monadic bind for Optionals
34. func >>= <A,B>(x: A?, f: A -> B?) -> B? Monadic bind for Optionals Optional Not Optional
35. func >>= <A,B>(x: A?, f: A -> B?) -> B? { switch x { case .None : return .None case .Some(let x) : return f(x) } } Boilerplate code is abstracted away
36. The monadic nature of Optional chaining let v = dict[1]?[2]?[3]?[4]?[5] let v = dict[1] >>= { $0[2] } >>= { $0[3] } >>= { $0[4] } >>= { $0[5] }
37. Two monadic binds are better than one ‘if let’ syntax
38. let v = dict[1]?[2]?[3]?[4]?[5] let v:String? ! if let a = dict[1], b = a[2], c = b[3], d = c[4], e = d[5] { v = e } else { v = .None } Two monadic binds are better than one
39. Three monadic binds are better than one flatMap
40. flatMap – a method on Optionals enum Optional<T> { func flatMap<U>(f: T -> U?) -> U? }
41. let v = dict[1]?[2]?[3]?[4]?[5] let v = dict[1].flatMap { $0[2] } .flatMap { $0[3] } .flatMap { $0[4] } .flatMap { $0[5] } Three monadic binds are better than one
42. Conclusion
43. Conclusion • The nil is dead. Long live the Optional.
44. Conclusion • The nil is dead. Long live the Optional. • Code without nil is saner code.
45. Conclusion • The nil is dead. Long live the Optional. • Code without nil is saner code. • Optionals are simple values, but do add complexity.
46. Conclusion • The nil is dead. Long live the Optional. • Code without nil is saner code. • Optionals are simple values, but do add complexity. • Monadic bind is a natural way to tame the complexity.
47. Conclusion • The nil is dead. Long live the Optional. • Code without nil is saner code. • Optionals are simple values, but do add complexity. • Monadic bind is a natural way to tame the complexity. • Swift deals with Optionals monadically, so do you.
48. Al Skipp alskipp @ChromophoreApp The End