Functional Programming For Rubyists

What is functional programming? And what can a Rubyists do with this knowledge? I gave this talk at the wonderful Cologne.rb :)

PS: There is a little mistake on the slides ;) I noticed it during the presentation – but now it's a nice exercise for you :P

PPS: "Why doesn't it succeed" is just a theory I believe in and in no way "fact" – just to make that clear ;)

Transcript

1. RWTH Aachen, Computer Science Student triAGENS GmbH, Developer moon lum moonbeamlabs by Lucas Dohmen Functional Pro rammin for Rubyists λ
2. Ruby Smalltalk Perl Lisp (Matz)
3. “ Ruby is like Smalltalk and LISP ot to ether and ot a love child and then went o to work and hired Perl to be the nanny. Josh Susser in Thinkin in Objects (RubyConf 2012)
4. Imperative Declarative Procedural OOP Lo ical Functional
5. Models of Computation Turin M achine Church‘s λ-Calculus First order lo ic Functional Pro ram m in Lo ical Pro rammin Im perative Lan ua es
6. Church-Turin thesis • All al orithmically computable functions can be pro rammed on a Turin Machine (Turin ) • All al orithmically computable functions can be pro rammed with the λ-calculus (Church) • Corollary: Turin Machines and λ-calculus can do all the same stu (Dohmen)
7. Functional Lan ua es • Lisp Family • Scheme, Common Lisp, Clojure (& Dylan) • ML Family • Haskell • Erlan • Scala
8. LISP vs. Haskell • Invented by McCarthy (1958) • Used since the dawn of time • You can use it in any paradi m (see CLOS) • Uncountable number of dialects • Desi n by committee (First draft 1990) • Developed in the Ivory Tower • Purity and Laziness as hi hest principles • One clearly defined lan ua e
9. LISP vs. Haskell • Invented by McCarthy (1958) • Used since the dawn of time • You can use it in any paradi m (see CLOS) • Uncountable number of dialects • Desi n by committee (First draft 1990) • Developed in the Ivory Tower • Purity and Laziness as hi hest principles • One clearly defined lan ua e C was introduced in 1972
10. λ-Calculus LISP is a pimped Lambda Calculus The smallest pro rammin lan ua e that exists
11. A short example (( x. plus x 1) 4)
12. A short example (( x. plus x 1) 4) (plus 4 1) β-reduction
13. A short example (( x. plus x 1) 4) With iven δ: = {plus( x, y ) ! x + y } (plus 4 1) β-reduction
14. A short example (( x. plus x 1) 4) With iven δ: = {plus( x, y ) ! x + y } (plus 4 1) β-reduction δ-reduction 4
15. Why you can‘t use Ruby as a functional lan ua e
16. Quiz Time (yep, the theory stu is over) a = puts "b" Where is the side e ect?
17. • One of the hard parts of testin • Haskell only allows side e ects with Monads • Ruby or LISP do not mark them in any way • In Haskell unit testin is really simple Side E ects
18. No Proper Tail Calls • The bi di erence between iterative and recursive pro rammin • Without tail call optimization, every recursive call will add another frame to the call stack • Rule of Thumb: If your lan ua e doesn‘t have PTCs, you should hold your horses with recursive functions
19. Where you can use Ruby‘s functional herita e
20. • In Ruby they all take blocks, not methods (doesn‘t make them less hi her order) • You all know each • …but there are also map, reduce, inject… • Look into the documentation of Enumerable :) Hi her Order Functions
21. How is it implemented? def collect if block_given? ary = [] each do |*o| ary << yield(*o) end ary else to_enum :collect end end alias_method :map, :collect (Implementation in Rubinius)
22. How is it implemented? (Implementation in Rubinius) def each return to_enum(:each) unless block_given? i = @start total = i + @total tuple = @tuple while i < total yield tuple.at(i) i += 1 end self end
23. Lazy Evaluation • Only evaluate a statement if there is no way around that • Ruby is quite lazy • But Haskell is really, really lazy • I‘m talkin Dude-level lazy 1 or this_variable_does_not_exist # => 1
24. Show me somethin • Task: Find the sum of the first x numbers that are dividable by 3 or 5 • First lets write it in idiomatic Haskell • Then lets emulate it with Ruby (2.0)
26. -- Step 1: -- An infinite list of all positive integers [1..]
27. -- Step 1: -- An infinite list of all positive integers [1..] -- Step 2: -- Now only those that are dividable by 3 and 5 [n | n <- [1..], n `mod` 3 == 0 || n `mod` 5 == 0]
28. -- Step 1: -- An infinite list of all positive integers [1..] -- Step 2: -- Now only those that are dividable by 3 and 5 [n | n <- [1..], n `mod` 3 == 0 || n `mod` 5 == 0] This is a so called uard [ n | n 2 N, n mod 3 = 0 , n mod 5 = 0] It is inspired by… math!
29. -- Step 1: -- An infinite list of all positive integers [1..] -- Step 2: -- Now only those that are dividable by 3 and 5 [n | n <- [1..], n `mod` 3 == 0 || n `mod` 5 == 0] -- Step 3: -- Only the first x take x [...]
30. -- Step 1: -- An infinite list of all positive integers [1..] -- Step 2: -- Now only those that are dividable by 3 and 5 [n | n <- [1..], n `mod` 3 == 0 || n `mod` 5 == 0] -- Step 3: -- Only the first x take x [...] -- Step 4 -- Add them foldl (+) 0 (take x [...])
31. foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0])
32. foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0]) (1..Float::INFINITY)
33. foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0]) (1..Float::INFINITY).lazy
34. . .select { |n| n % 3 == 0 || n % 5 == 0 } foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0]) (1..Float::INFINITY).lazy
35. . .select { |n| n % 3 == 0 || n % 5 == 0 } foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0]) (1..Float::INFINITY).lazy .take(x)
36. . .select { |n| n % 3 == 0 || n % 5 == 0 } foldl (+) 0 (take x [n | n <- [1..], n `mod` 5 == 0 || n `mod` 3 == 0]) (1..Float::INFINITY).lazy .take(x).inject(0, :+)
37. Fun Fact • Fold is also known as foldl, reduce, accumulate, compress or inject • This is of course not confusin at all • LISP is to blame
38. Immutability • In Haskell, everythin is immutable • In Ruby, almost everythin is mutable • hamster em: E cient, Immutable, Thread- Safe Collection classes for Ruby • adamantium em: Immutable extensions to objects
39. require "adamantium" class Wolverine include Adamantium attr_accessor :health def initialize @health = 100 end end wolverine = Wolverine.new p wolverine.health #=> 100 wolverine.health = 211 #=> can't modify frozen Wolverine (RuntimeError)
40. require "adamantium" class Wolverine include Adamantium attr_accessor :health def initialize @health = 100 end end wolverine = Wolverine.new p wolverine.health #=> 100 wolverine.health = 211 #=> can't modify frozen Wolverine (RuntimeError) Warnin ! This lib is confusin
41. Wrappin up…
42. Why doesn‘t it succeed? • Not a ood model for the world • Lar e systems tend to separate into communicatin sub systems… • … and that is pretty much Alan Kay‘s idea
43. Still… • It‘s a lot of fun to play around with • It‘s a ood fit for certain problem types • It‘s a nice exercise for the brain to try a di erent paradi m • … and immutability and no side e ects are the key to parallel pro rammin ;)
44. Further Readin /Listenin • Book: Land Of Lisp • Talk: Jim Weirich‘s Y Not – Adventures in Functional Pro rammin • Blo Article: Pro rammin with Nothin