Arrow Fx - Functional Programming for the masses

One of the big cons of Functional Programming can be the learning curve. In this talk, we’ll learn how to encode “effectful” programs in a controlled way following the FP principles through a direct syntax. You’ll think you’re writing imperative code! Some additional bits we’ll learn:

- What’s an effect
- Why we’d want to keep it under control
- How to control errors and encode deferred execution through IO and further more powerful data types to be released.
- How to use the power of Kotlin suspension system to enforce us to keep our side effects under control.
- And much more.

Transcript

1. 
2. Hi , I am Jorge Castillo, Tech Lead @47deg @jorgecastillopr 
3. Is Kotlin a functional language? 
4. Some valid features ✅ high order functions (functions as values) . val for immutability (properties). Algebraic data types. Sum & Product types (sealed class + data class). Enhances determinism (expressions & exhaustive evaluation). 
5. Is it enough? Nope . It still lacks some important features: type classes, higher kinded types... Something on top of was needed! 
6. Bringing ΛRROW to life 
7. Started as a learning exercise in the Spanish Android Slack community. 
8. Enables Pure Functional Programming over Kotlin. 
9. It's highly modular 
10. How can I use it everyday? 
11. Effectful programs & determinism 
12. Majority of programs contain uncontrolled "effects" . (Query data bases, perform network requests, print to console, render UI...) They escape program's control (can fail, be slow, mutate program's state, race conditions...) 
13. Problem? Unexpected results whenever an effect runs. Non deterministic programs . Frequently called side effects. 
14. Solution? We want program's logic to avoid side effects at all cost, so it can stay deterministic. But, can we avoid them at all? 
15. Solution ✅ Push side effects to the "edge of the world" (program's entry point). Android Application or Activity Rest API controllers other programs main() 
16. How? Depend on abstractions. (Same than OOP! ) Provide implementation details when running it. Effects are implementation details. 
17. Let's step back Our program is composed by functions. A function without side effects is called "pure" ✨. 
18. Pure functions 
19. What is it? A function that is deterministic. Given the same inputs produces the same output without observable world changing effects. 
20. Some small exercises ✏ 
21. Is this pure or impure? Target platform: JVM Running on kotlin v. 1.3.31 fun printHelloWorld() Unit = println("Hello World!") val result = printHelloWorld() 
22. How to make it pure? Defer execution (return a function) Target platform: JVM Running on kotlin v. 1.3.31 fun printHelloWorld() = { println("Hello World!") } val computation = printHelloWorld() 
23. How to make it pure? Alternative: Wrap it into the functional type IO<A>. Defers execution. Fits well in Functional codebases. 
24. Is this pure or impure? Target platform: JVM Running on kotlin v. 1.3.31 fun printHelloWorld() IO<Unit> = IO { println("Hello World!") } val result = printHelloWorld() 
25. Pure! The thunk is still not run, the computation stays pure until you explicitly run it. 
26. Is this pure or impure? Target platform: JVM Running on kotlin v. 1.3.31 suspend fun printHelloWorld() Unit = println("Hello World!") val result = printHelloWorld() 
27. Why? Suspended functions cannot run outside of an already suspended context. It's unsafe to call them in "the environment" . Kotlin compiler disallows you to run side effects in unsafe places. 
28. The suspended future 
29. @RestrictSuspension suspend fun printOuterHelloWorld() Unit = println(helloWorld()) suspend fun Restricted.printInnerHelloWorld() Unit = println(helloWorld()) @RestrictsSuspension class Restricted { suspend fun y() Unit = printOuterHelloWorld() fails to c suspend fun x() Unit = printInnerHelloWorld() works! } 
30. suspend fun + ΛRROW 
31. ΛRROW Fx Pure functional effects on top of ΛRROW and Kotlin Coroutines System. Leverages direct syntax to write pure functional programs. 
32. Fx DSL 4 primitives to write any possible program. fx {}, effect{}, bind(), unsafe {}. 
33. fx {} Represents a deferred program that can contain effects. Target platform: JVM Running on kotlin v. 1.3.31 suspend fun printHello() Unit = println("Hello world") fun program() IO<Unit> = fx { printHello() } 
34. You can't plainly run effects in the program! 
35. effect {} Accepts an effect in the program. Wraps the side effects. Target platform: JVM Running on kotlin v. 1.3.31 suspend fun printHello() Unit = println("Hello world") fun program() = fx { effect { printHello() } } 
36. ! (or .bind()) Resolves the effect. Equivalent to flatMap(). Target platform: JVM Running on kotlin v. 1.3.31 suspend fun printHello() Unit = println("Hello World") fun program() IO<Unit> = fx { !effect { printHello() } } fun main() { println(program()) } 
37. bind() removes nesting - service1().flatMap { result1 - service2(result1).flatMap { result2 - service3(result2).map { result3 - Result(result3) - } - } - } + val result1 = !service1() + val result2 = !service2(result1) + val result3 = !service3(result2) + Result(result3) 
38. unsafe {} Perform effects at the edge of the world. Target platform: JVM Running on kotlin v. 1.3.31 fun program() IO<Unit> = fx { !effect { println("Hello World") } } fun main() { edge of the world unsafe { runBlocking { program() } } } 
39. Polymorphism Make your program parametric to any F. Target platform: JVM Running on kotlin v. 1.3.31 fun <F> Fx<F>.program() Kind<F, Unit> = fx { !effect { println("HelloWorld") } } fun main() { val fx = IO.fx() IO<A> as F unsafe { runBlocking { fx.program() } } } 
40. Asynchronous Fibers (Lightweight async processes) 
41. Asynchronous fibers: Easy to spawn and manage Target platform: JVM Running on kotlin v. 1.3.31 fx { val op = effect { Thread.currentThread().name } val fiber = !NonBlocking.startFiber(op) val threadName: String = !fiber.join() !effect { println(threadName) } } 
42. Asynchronous Fibers Recovering from async errors 
43. Asynchronous fibers: Recovering from async errors Target platform: JVM Running on kotlin v. 1.3.31 fx { val op = effect { throw RuntimeException("BOOM!") } val fiber = !NonBlocking.startFiber(op) val recovery = { error: Throwable effect { println("recovering from async exception" } !fiber.join().handleErrorWith(recovery) } 
44. Concurrency: Races Target platform: JVM Running on kotlin v. 1.3.31 fx { val op1 = effect { Thread.currentThread().name } val op2 = effect { Thread.currentThread().name } val op3 = effect { Thread.currentThread().name } val result = !NonBlocking.raceN(op1, op2, op3) !effect { println(result) } } 
45. Concurrency: concurrent non blocking map 
46. Concurrency: Direct style concurrent non blocking map Target platform: JVM Running on kotlin v. 1.3.31 fx { val (a, b, c) = !NonBlocking.parMapN( effect { Thread.currentThread().name }, effect { Thread.currentThread().name }, effect { Thread.currentThread().name }, Tuple3 ) !effect { println(listOf(a, b, c)) } } 
47. Concurrency: Error handling 
48. Concurrency: Error handling Target platform: JVM Running on kotlin v. 1.3.31 fx { val res = !NonBlocking.parMapN( effect { Thread.currentThread().name }, effect { throw RuntimeException("BOOM!") }, effect { Thread.currentThread().name }, Tuple3 ).handleErrorWith { error: Throwable effect { println("One of the ops failed!") } } !effect { println(res) } } 
49. Switching execution contexts Target platform: JVM Running on kotlin v. 1.3.31 val program = fx { continueOn(NonBlocking) val t1 = !effect { Thread.currentThread().name } continueOn(BlockingIO) val t2 = !effect { Thread.currentThread().name } continueOn(UI) val t3 = !effect { Thread.currentThread().name } !effect { println("$t1 $t2 $t3") } } 
50. Bracket: Safe resource acquisition 
51. Bracket: Canceled the usage 
52. Bracket: Error while using it 
53. Target platform: JVM Running on kotlin v. 1.3.31 val program = fx { val acquire = effect { File("data.json").open() } val use = { file: File effect { println(file.toString() val release = { file: File, exitCase: ExitCase effect { when (exitCase) { is ExitCase.Completed println("complete is ExitCase.Canceled println("canceled" is ExitCase.Error println("error") } file.close() println("File closed") } } !acquire.bracketCase(release, use) } 
54. Built in Cancellation Target platform: JVM Running on kotlin v. 1.3.31 fun canceler() = fx { val (_, cancel) = !NonBlocking.startFiber(infiniteLoop()) !effect { delay(100) } !effect { println("main: I'm tired of waiting!") } !cancel !effect { println("main: Now I can quit.") } } 
55. Abstracts over function arity Target platform: JVM Running on kotlin v. 1.3.31 val program = fx { val op1 = effect { "first" } val op2 = effect { 2 } val race = !NonBlocking.raceN(op1, op2) val winner = race.fold({ "first one won" }, { "second one !effect { println(winner) } } 
56. Fx for all Monads Fx over Option Target platform: JVM Running on kotlin v. 1.3.31 fx { val one = !Option(1) val two = !Option(one + one) two } 
57. Alternative ! styles (_) destructuring syntax Target platform: JVM Running on kotlin v. 1.3.31 fx { val (one) = Option(1) val (two) = Option(one + one) two } 
58. Alternative ! styles explicit bind() Target platform: JVM Running on kotlin v. 1.3.31 fx { val one = Option(1).bind() val two = Option(one + one).bind() two } 
59. Ecosystem and roadmap 
60. KEEP-87 We want to make Typed FP in Kotlin even easier 
61. KEEP-87 Big expectations from the Kotlin community 
62. Where is the code ? and -> @tomasruizlopez @jorgecastillopr KEEP-87 
63. KEEP-87 Proposes Compile time DI. Families (scopes) of functions validated and injected at compile time. 
64. KEEP-87 KEEP is already submitted ✅ . We're gathering feedback and will iterate further after JetBrains review. 
65. Upcoming libraries Helios: Hyper fast serialization library (optics based! awesome syntax) ⚡ . Kollect: Efficient data loading from heterogeneous sources of data . Both are FP oriented, fit well in any programs using Kotlin + FP. More to come!: Streams, Android... 
66. Helios 0.1.0 
67. Where's Arrow? Already available in Maven Central and JCenter. Aiming for a first stable release around the end of 2019 . 
68. We want you in 
69. Join us! Github Slack Gitter We are beginner friendly and provide 1:1 mentoring for both users & new contributors! +110 Contributors and growing! https://github.com/arrow-kt https://kotlinlang.slack.com/messages/C5UPMM0A0 https://gitter.im/arrow-kt/Lobby 
70. 