Recommended
Recommended
More Related Content
Similar to The Functional Rubyist: A Primer
Similar to The Functional Rubyist: A Primer (20)
Recently uploaded
Recently uploaded (20)
The Functional Rubyist: A Primer
- 1. @jleo3 The Functional Rubyist A primer
- 2. @jleo3 joe leo (lucy’s daddy) twitter/github/linkedin: @jleo3
- 3. @jleo3 def method() TOGETHER WE WILL BUILD SOMETHING GREAT
- 4. @jleo3
- 6. @jleo3
- 8. @jleo3
- 9. @jleo3 a note on purity Ruby Java 7 PHP Lisp
- 10. @jleo3 a purely functional language... ...guarantees referential transparency RUBY DOES NOT
- 11. @jleo3 A purely functional language... ...guarantees immutability RUBY DOES NOT
- 12. @jleo3 { haskell bullies }
- 13. @jleo3 side effects are necessary to do interesting things ● I/O ● raising exceptions ● outputting data to the terminal ● updating a record in a database ● anything else that changes state
- 14. @jleo3 what do most people mean when they fp? Remove side effects! Curry! Generics! Lazy Evaluation! Recurse! Tail-call optimize!
- 16. @jleo3 let ruby be your guide!
- 17. @jleo3 side-effect-free ruby ● String.upcase ● Enumerable.map ● Array.filter
- 18. @jleo3 bang! a side effect ● “my string”.upcase! ● [1, 2, 3, 4] << 5 ● { x: “ruby” }.fetch(:y)
- 19. @jleo3 an example Student#calculate_grade def calculate_grade(scores, student) case scores.sum / scores.size when 90..100 student.update_grade("A") when 80...90 student.update_grade("B") when 70...80 student.update_grade("C") when 60...70 student.update_grade("D") else student.update_grade("F") end end Student#calculate_grade def calculate_grade(scores) case scores.sum / scores.size when 90..100 "A" when 80...90 "B" when 70...80 "C" when 60...70 "D" else "F" end end
- 20. @jleo3 what is currying? breaking down… ● 1 function with many arguments… ● ...into many functions, each with 1 argument
- 21. @jleo3 what is currying? simple example: add add = -> (a, b) { a + b } #(1 function, 2 arguments) curried_add = -> (a) { -> (b){ a + b } } #(2 functions, each with 1 argument)
- 22. @jleo3 what is partial function application? ● Pass in a number of arguments less than the function’s arity ● Result: a new function with all of the passed-in arguments applied add = -> (a, b) { a + b } add = -> (5, b) { 5 + b } # partially applied; NOT VALID SYNTAX
- 23. @jleo3 but I’m lazy! i don’t want to have to think about all of that! ● You don’t have to! ● curry handles both currying and partial function application. ● add.curry
- 24. @jleo3 into action with curry and partial function application find_multiples = -> (x, arr) { arr.select { |el| el % x == 0 } }
- 25. @jleo3 Unique IRL; Generic in code ● Functions that return functions ● Building blocks for more specific functions ● Generics are to FP what Objects are to OOP
- 26. @jleo3 into action with curry and partial function application Generic: find_multiples_of = find_multiples.curry Individuated: find_multiples_of_3 = find_multiples_of.call(3) find_multiples_of_5 = find_multiples_of.call(5)
- 27. @jleo3 thinking in streams Find infinite multiples! find_first_multiples = -> (num, mult) { (1..).lazy.select { |x| x % mult == 0 }.first(num) }
- 28. @jleo3 recurse! Writing recursive functions is all about determining the “terminal clause.” Popular recursive functions: ● Factorial (terminal clause: x <= 1) ● Fibonacci (terminal clause: x <= 1) ● Sum Squares (terminal clause: x == 0)
- 29. @jleo3 VM, optimize thyself! RubyVM::InstructionSequence.compile_option = { tailcall_optimization: true, trace_instruction: false } demystifying tail-call optimization
- 30. @jleo3 demystifying tail-call optimization def factorial(x) return x if x == 2 x * factorial(x - 1) end def factorial(x, acc=1) return acc if x <= 1 factorial(x - 1, x * acc) end (RECURSIVE) (TAIL RECURSIVE)
- 31. @jleo3 Where can I learn more? You guessed it!
- 32. @jleo3 Where can I learn more? But also...
- 33. @jleo3 Thank you! Also, get @ me! - joe leo - twitter/github/linkedin: @jleo3 - defmethod.com Thank you to… - everyone at Rubyconf - Matz - Abby and the Program Committee - David A. Black
Editor's Notes
- Insert green checkmarks; swap words for language symbols; animate to show the others one at a time Yes, Ruby is a functional programming language. FP is any language that supports functions. Ruby does this with lambdas and procs Matz was primarily inspired by Lisp when he created Ruby. Also functional. Java does it with closures (since Java 7) PHP supports first-class functions
- referential transparency: a function without side effects animate red x (examples: upcase vs upcase!; <<)
- Animate “Ruby does not” But wait! What about Object#freeze? What about frozen strings? At the CRuby freezing an object in Ruby is really just setting a bit. Since the bit can be flipped, it’s not guaranteed immutable
- change text to ruby (more examples: [1,3,5].fetch(2); .fetch(3))
- less code because it’s doing less updating a db may happen, but it’s not necessary to update an in-memory object (like an active record object)
- Holden Caulfield
- animate: each function, one at a time animate: circle add and curried_add - “these are functionally equivalent” animate: circle 2nd curried_add with note “the ruby way” these are both lambdas (using stabby lambda syntax) they are both valid ruby syntax, as we’ll see curried_add is the curried form of add but you can’t call curried_add the same way (demonstrate)
- used when we know some, but not all, of a function’s arguments the second line is not valid ruby syntax, but curry achieves the same thing. Which brings me to...
- Ingatius J. Reilly
- demo find_multiples_of_3 and find_multiples_of_5 For more info on currying and partial function application, see my recent RubyTapas episode
- New in Ruby 2.6 you can use the infinite range syntax Float::INFINITY lazy evaluation is not unique to FP, but delayed evaluation is core to functional programming allows us to start thinking in terms of “streams of data” rather than finite sets
- we can do this without talking about stacks and stack frames! note the accumulator The last line of a tail recursive function is a call to the function itself.