Functional Programming for Rubyst's

Transcript

1. Functional Programming for Rubyst’s by @orendon @RubyMedellin - http://medellinrb.org
2. - Concepts - Immutability/ Side effects - Referential Transparency - Concurrency/Parallelism - High Order Functions - Currying - Tail Call/Recursion - more... Agenda
3. History - Lambda Calculus, 30’s - LISP, 50’s - ML’s, 70’s - Haskell, 80’s - Elixir, Erlang, Clojure, Scala, Elm, Idris, etc... https://en.wikipedia.org/wiki/Functional_programming
4. Functional Programming “Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data” https://en.wikipedia.org/wiki/Functional_programming
5. Functional Programming - Mathematical functions - Avoids state - Immutable data
6. Functional Programming - Cleaner Code - Memoization - Parallelization - Modularity - Easier debugging
7. Mutable Data x = x + 1
8. Mutable Data x = x + 1 x - x = 1
9. Mutable Data x = x + 1 x - x = 1 0 = 1
10. Immutable Data x = 1 y = x + 1 x = y -1
11. Referential Transparency y = f(x) - Mathematical Functions - Depends on inputs - Memoization - Idempotence
12. State result = func_a(x) + func_b(y) - func_c(z) - No State? - Hidden State - Explicit State
13. Concurrency / Parallelism y = f(x) - No side effects - No shared data
14. Concurrency / Parallelism Just Simpler: - No locks - No semaphores - No race conditions - No dead-locks
15. High Order Functions def apply_math(fn, a, b) a.send(fn, b) end apply_math(:+, 1, 2)
16. DEMO
17. Currying apply_math = lambda do |fn, a, b| a.send(fn, b) end add = apply_math.curry.(:+) subtract = apply_math.curry.(:-) multiply = apply_math.curry.(:*) divide = apply_math.curry.(:/) add.(1, 2)
18. DEMO
19. Recursion - Loops - Recursion - Call Stack - Tail Call - Tail Recursion - Tail Call Optimization (TCO)
20. Factorial def fact(n) factorial = 1 while n > 1 factorial *= n n -= 1 end factorial end - How vs What - Holding State - Readable?
21. Factorial def fact(n) return 1 if (0..1).include?(n) n * fact(n-1) end - Recursive - Call Stack Error - Not Tail Recursive
22. Factorial def fact(n, acc=1) return acc if n <= 1 fact(n-1, n*acc) end - Recursive - Call Stack Error - Tail Recursive
23. DEMO
24. TCO in Ruby RubyVM::InstructionSequence.compile_option = { tailcall_optimization: true, trace_instruction: false } def fact(n, acc) return acc if n <= 1 fact(n-1, n*acc) end
25. Lazyness - Eager Evaluation - Lazy Evaluation - Enumerable - Enumerable::Lazy (Ruby 2)
26. Benchmark require 'benchmark' Benchmark.bm do |x| x.report("eager") do (1..100_000_000).map{ |x| x*2 }.take(10) end x.report("lazy") do (1..100_000_000).lazy.map{ |x| x*2 }.take(10).to_a end end
27. DEMO
28. Thanks Empanada time!