Introduction to algebraic effects on ruby

TL;DR
ruby implementation of this article https://dev.to/yelouafi/algebraic-effects-in-javascript-part-1---continuations-and-control-transfer-3g88

Transcript

2. algebraic effects under the hood Vitalii Pecherin 2019
3. https://github.com/we138/path-to-effects
5. https://github.com/dry-rb/dry-effects
7. functions and side effects
10. • making a HTTP request • mutating data • printing to a log or console • Random.rand • getting the current time
11. Why functions without side effects are better?
12. • pure functions are easy to test • side effects can make code complicated • pure functions are easy to use in parallel
14. without side effects, you can't perform I/O operations, so you can't make a useful application
15. side effects are a necessary evil, and one should seek to minimize/ localize/isolate them
16. effects meets handlers
17. https://www.microsoft.com/en-us/research/project/koka/
18. https://www.eff-lang.org
19. https://overreacted.io/algebraic-effects-for-the-rest-of-us/
20. https://github.com/ocamllabs/ocaml-effects-tutorial#12-basics
21. https://gist.github.com/flash-gordon/38dfb992ddc54b6bb45f2fb319e0a812
22. effect handlers are similar to exception handlers, but handles continuation and continues it
23. https://dev.to/yelouafi
24. https://dev.to/yelouafi/algebraic-effects-in-javascript-part-4--- implementing-algebraic-effects-and-handlers-2703
25. control flow and call stack
26. stack frame frame 
 pointer variables and 
 blocks function
 arguments
27. return-based, classical style (aka direct style)
34. control is returned to the main program over and over after exiting a function
36. continuation passing style aka CPS
37. • The function takes a callback as an additional argument • The function never returns its result. It always uses the callback to communicate its result CPS
41. continuations control via ruby fibers
42. Fibers are primitives for implementing light weight cooperative concurrency in Ruby. Basically they are a means of creating code blocks that can be paused and resumed, much like threads. https://devdocs.io/ruby~2.6/fiber
43. https://devdocs.io/ruby~2.6/fiber
51. continuations
52. The idea of a continuation is that it captures the remaining computation left to be evaluated
59. delimited continuations
63. shift meets reset
64. • reset mark on the stack as the limit of the continuation to be captured • shift jumps back to where that mark was, i.e. where you used reset, and saves the portion of the program between that and where you called shift
65. https://docs.racket-lang.org
79. let’s shift “shift”
83. capture delimited continuations
84. in our case it is just capture frames between reset/shift
94. algebraic effects and handlers
95. We start with exception handlers because exceptions provide the simplest example of algebraic effects.
96. abort handler
107. read handler
108. https://overreacted.io/algebraic-effects-for-the-rest-of-us/
115. more effects
116. • exception • retry • scheduler • state • random • time • async/await • parallel
 • log
117. thanks!