Demystifying Functional Programming

Transcript

1. Demystifying Tomás Ruiz-López @tomasruizlopez Functional Programming Swifters December 2020
2. HARD… Functional Programming is
3. EASY! Functional Programming is
4. Functional Programming? What is
5. Functions Programming with
6. Provide output for every input Total
7. Total func divide(_ x: Double, _ y: Double) -> Double
8. Total func divide(_ x: Double, _ y: Double) -> Double { guard y != 0 else { fatalError("Denominator cannot be zero") } return x / y }
9. Total func divide(_ x: Double, _ y: Double) throws -> Double { guard y != 0 else { throw DivideError.divisionByZero } return x / y }
10. Total func divide(_ x: Double, _ y: Double) -> Result<Double, DivideError> { guard y != 0 else { return .failure(.divisionByZero) } return .success(x / y) }
11. Deterministic Provide the same output for a given input
12. Deterministic func makeFilename(prefix: String, extension ext: String) -> String { let now = Date() return "\(prefix)-\(now).\(ext)" }
13. Deterministic func makeFilename(prefix: String, extension ext: String, now: Date) -> String { return "\(prefix)-\(now).\(ext)" }
14. Pure Only compute output, and nothing else
15. Pure “How can I do something useful in my app without side e f f ects?”
16. Pure func greet(name: String) -> Void { print("Hello \(name)!") } greet(name: “Swifters") > Hello Swifters!
17. Pure func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() }
18. Pure func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") > Hello Swifters!
19. Pure func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() }
20. Pure func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") >
21. Pure func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() } let cancellable = greet(name: “Swifters").sink { _ in } > Hello Swifters!
22. Pure Why does it matter?
23. reasoning We want to have a sound about our code
24. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() }
25. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() } let cancellable = greet(name: "Swifters").flatMap { _ in greet(name: “Swifters") }.sink { _ in }
26. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() } let cancellable = greet(name: "Swifters").flatMap { _ in greet(name: “Swifters") }.sink { _ in } Solution: 2
27. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") let cancellable = publisher.flatMap { _ in publisher }.sink { _ in }
28. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Future { promise in print("Hello \(name)!") promise(.success(())) }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") let cancellable = publisher.flatMap { _ in publisher }.sink { _ in } Solution: 1
29. Referential Transparency Eager evaluation breaks
30. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() }
31. Quiz How many times does it print “Hello Swifters!”? let cancellable = greet(name: "Swifters").flatMap { _ in greet(name: “Swifters") }.sink { _ in } func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() }
32. Quiz How many times does it print “Hello Swifters!”? let cancellable = greet(name: "Swifters").flatMap { _ in greet(name: “Swifters") }.sink { _ in } Solution: 2 func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() }
33. Quiz How many times does it print “Hello Swifters!”? func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") let cancellable = publisher.flatMap { _ in publisher }.sink { _ in }
34. Quiz How many times does it print “Hello Swifters!”? Solution: 2 func greet(name: String) -> AnyPublisher<Void, Never> { Deferred { Future { promise in print("Hello \(name)!") promise(.success(())) } }.eraseToAnyPublisher() } let publisher = greet(name: “Swifters") let cancellable = publisher.flatMap { _ in publisher }.sink { _ in }
35. Pure func greet(name: String) -> IO<Never, Void> { IO.invoke { print("Hello \(name)!") } } greet(name: “Swifters").unsafeRunSync() > Hello Swifters! bow-swift.io
36. side effects Model as values
38. Functional Programming This is all you need to know about
39. Composition Everything else is
40. Composition func compose<A, B, C>( _ g: @escaping (B) -> C, _ f: @escaping (A) -> B ) -> (A) -> C { { a in g(f(a)) } }
41. Composition func compose<A, B, C>( _ g: @escaping (B) -> C, _ f: @escaping (A) -> B ) -> (A) -> C { { a in g(f(a)) } } B C A
42. Composition func compose<A, B, C>( _ g: @escaping (B) -> C, _ f: @escaping (A) -> B ) -> (A) -> C { { a in g(f(a)) } } B C A g
43. Composition func compose<A, B, C>( _ g: @escaping (B) -> C, _ f: @escaping (A) -> B ) -> (A) -> C { { a in g(f(a)) } } B C A f g
44. Composition func compose<A, B, C>( _ g: @escaping (B) -> C, _ f: @escaping (A) -> B ) -> (A) -> C { { a in g(f(a)) } } B C A f g g · f
45. Composition func andThen<A, B, C>( _ f: @escaping (A) -> B, _ g: @escaping (B) -> C ) -> (A) -> C { { a in g(f(a)) } } B C A f g g · f
46. Higher-order Functions Possible thanks to
47. Composition is not always as easy
48. Composition func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> ??? { // What goes here? }
49. Composition B? A f func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> ??? { // What goes here? }
50. Composition B? A f C g B func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> ??? { // What goes here? }
51. Composition B? A f C g B func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> ??? { // What goes here? }
52. Composition B? A f C g B C? map func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> ??? { // What goes here? }
53. Composition func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C ) -> (A) -> C? { { a in f(a).map(g) } } B? A f C g B C? map
54. Composition func compose<A, B, C>( _ f: @escaping (A) -> [B], _ g: @escaping (B) -> C ) -> (A) -> [C] { { a in f(a).map(g) } } func compose<A, B, C>( _ f: @escaping (A) -> Result<B, Error>, _ g: @escaping (B) -> C ) -> (A) -> Result<C, Error> { { a in f(a).map(g) } }
55. Functor Compose functions using map func compose<F: Functor, A, B, C>( _ f: @escaping (A) -> F<B>, _ g: @escaping (B) -> C ) -> (A) -> F<C> { { a in f(a).map(g) } }
56. Higher-Kinded Types Not possible in Swift, we need
57. Functor Compose functions using map func compose<F: Functor, A, B, C>( _ f: @escaping (A) -> Kind<F, B>, _ g: @escaping (B) -> C ) -> (A) -> Kind<F, C> { { a in f(a).map(g) } } bow-swift.io
58. Composition func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> ??? { // What goes here? }
59. Composition B? A f func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> ??? { // What goes here? }
60. Composition B? A f C? g B func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> ??? { // What goes here? }
61. Composition B? A f C? g B func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> ??? { // What goes here? }
62. Composition B? A f C? g B C? f latMap func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> ??? { // What goes here? }
63. Composition B? A f C? g B C? f latMap func compose<A, B, C>( _ f: @escaping (A) -> B?, _ g: @escaping (B) -> C? ) -> (A) -> C? { { a in f(a).flatMap(g) } }
64. Composition func compose<A, B, C>( _ f: @escaping (A) -> [B], _ g: @escaping (B) -> [C] ) -> (A) -> [C] { { a in f(a).flatMap(g) } } func compose<A, B, C>( _ f: @escaping (A) -> Result<B, Error>, _ g: @escaping (B) -> Result<C, Error> ) -> (A) -> Result<C, Error> { { a in f(a).flatMap(g) } }
65. Monad Compose functions using f latMap func compose<F: Monad, A, B, C>( _ f: @escaping (A) -> F<B>, _ g: @escaping (B) -> F<C> ) -> (A) -> F<C> { { a in f(a).flatMap(g) } }
66. Monad Compose functions using f latMap func compose<F: Monad, A, B, C>( _ f: @escaping (A) -> Kind<F, B>, _ g: @escaping (B) -> Kind<F, C> ) -> (A) -> Kind<F, C> { { a in f(a).flatMap(g) } } bow-swift.io
67. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> ??? { // What goes here? }
68. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> ??? { // What goes here? } A? B?
69. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> ??? { // What goes here? } A? B? A B C f
70. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> ??? { // What goes here? } A? B? A B C f
71. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> ??? { // What goes here? } A? B? A B C f C? zip
72. Composition func zip<A, B, C>( _ a: A?, _ b: B?, with f: @escaping (A, B) -> C ) -> C? { a.flatMap { x in b.map { y in f(x, y) } } } A? B? A B C f C? zip
73. Composition func zip<A, B, C>( _ a: [A], _ b: [B], with f: @escaping (A, B) -> C ) -> [C] { a.flatMap { x in b.map { y in f(x, y) } } } func zip<A, B, C>( _ a: Result<A, Error>, _ b: Result<B, Error>, with f: @escaping (A, B) -> C ) -> Result<C, Error> { a.flatMap { x in b.map { y in f(x, y) } } }
74. cumbersome Functional Programming terminology is
75. unfamiliar Functional Programming terminology is
77. Composition func loadWebResource(_ path: String) -> Resource? func decodeImage(_ r1: Resource, _ r2: Resource) -> Image? func dewarpAndCleanup(_ image: Image) -> Image? func processImageData() -> Image? { loadWebResource("dataprofile.txt").flatMap { dataRes in loadWebResource("imagedata.dat").flatMap { imageRes in decodeImage(dataRes, imageRes).flatMap { imageTmp in dewarpAndCleanup(imageTmp) } } } }
78. Composition func loadWebResource(_ path: String) -> Resource? func decodeImage(_ r1: Resource, _ r2: Resource) -> Image? func dewarpAndCleanup(_ image: Image) -> Image? func processImageData() -> Image? { loadWebResource("dataprofile.txt").flatMap { dataRes in loadWebResource("imagedata.dat").flatMap { imageRes in decodeImage(dataRes, imageRes).flatMap { imageTmp in dewarpAndCleanup(imageTmp) } } } }
79. Composition func loadWebResource(_ path: String) -> Resource? func decodeImage(_ r1: Resource, _ r2: Resource) -> Image? func dewarpAndCleanup(_ image: Image) -> Image? func processImageData() -> Image? { if let dataRes = loadWebResource("dataprofile.txt"), let imageRes = loadWebResource("imagedata.dat"), let imageTmp = decodeImage(dataRes, imageRes) { return dewarpAndCleanup(imageTmp) } else { return nil } }
80. Composition func loadWebResource(_ path: String) -> Result<Resource, Error> func decodeImage(_ r1: Resource, _ r2: Resource) -> Result<Image, Error> func dewarpAndCleanup(_ image: Image) -> Result<Image, Error> func processImageData() -> Result<Image, Error> { loadWebResource("dataprofile.txt").flatMap { dataRes in loadWebResource("imagedata.dat").flatMap { imageRes in decodeImage(dataRes, imageRes).flatMap { imageTmp in dewarpAndCleanup(imageTmp) } } } }
81. Composition func loadWebResource(_ path: String) -> AnyPublisher<Resource, Error> func decodeImage(_ r1: Resource, _ r2: Resource) -> AnyPublisher<Image, Error> func dewarpAndCleanup(_ image: Image) -> AnyPublisher<Image, Error> func processImageData() -> AnyPublisher<Image, Error> { loadWebResource("dataprofile.txt").flatMap { dataRes in loadWebResource("imagedata.dat").flatMap { imageRes in decodeImage(dataRes, imageRes).flatMap { imageTmp in dewarpAndCleanup(imageTmp) } } } }
82. Monad Comprehensions Composition meets imperative syntax
83. Composition func loadWebResource(_ path: String) async throws -> Resource func decodeImage(_ r1: Resource, _ r2: Resource) async throws -> Image func dewarpAndCleanup(_ image: Image) async throws -> Image func processImageData() async throws -> Image { let dataRes = await try loadWebResource("dataprofile.txt") let imageRes = await try loadWebResource("imagedata.dat") let imageTmp = await try decodeImage(dataRes, imageRes) return await try dewarpAndCleanup(imageTmp) }
85. Composition func processImageData() -> IO<Error, Image> { let dataRes = IO<Error, Resource>.var() let imageRes = IO<Error, Resource>.var() let imageTmp = IO<Error, Image>.var() let image = IO<Error, Image>.var() return binding { dataRes <- loadWebResource("dataProfile.txt") imageRes <- loadWebResource("imagedata.dat") imageTmp <- decode(dataRes.get, imageRes.get) image <- dewarpAndCleanup(imageTmp.get) } yield: { image.get }^ } bow-swift.io
87. awesome Swift is for Functional Programming
89. Why choose? Take what’s best from both
90. Demystifying Tomás Ruiz-López @tomasruizlopez Functional Programming Swifters December 2020