Functional Programming in Ruby with Lambdas

Functional Programming in Ruby with Lambdas

The Problem

Object Oriented Design is powerful for organizing software behavior, but without the benefit of lambdas' code-as-data flexibility, in many cases it fails to reduce solutions to their simplest form.

Functional programming has been gaining popularity, and many Rubyists have embraced functional languages such as Elixir and Clojure. While Ruby generally isn't considered a functional language, it does have lambdas and a rich Enumerable library.

Although Ruby's Enumerable functionality is widely appreciated and used, its lambdas generally are not.

The Solution

This presentation introduces the developer to lambdas, and shows how they can be used to write software that is cleaner, simpler, and more flexible.

We'll go through lots of code fragments, exploring diverse ways of exploiting the power of lambdas, and identifying reusable functional design patterns along the way.

486ca04f06d968004643ce5b47376ded?s=128

keithrbennett

October 06, 2020
Tweet

Transcript

  1. Functional Programming in Ruby with Lambdas Chicago Ruby Online Meetup

    October 6, 2020 Keith R. Bennett Bennett Business Solutions, Inc. Github, LinkedIn, Twitter, Speakerdeck, StackOverflow (@)keithrbennett on GMail, LinkedIn, Speakerdeck, Twitter 1
  2. Disclaimer 2 I am not a functional programming expert. The

    material I present today is based on my very limited experience with Clojure, Elixir, and Erlang, and my exploration in my primary and favorite language, Ruby.
  3. 3 A lambda is a free floating function. It does

    not belong to, or is even associated with, an object or class.
  4. 4 "Functions in a functional language are considered first class,

    meaning that functions can appear anywhere that any other language construct (such as variables) can appear.” –Neal Ford
  5. 5 "...by enabling functions as return values, you create the

    opportunity to build highly dynamic, adaptable systems.” – Neal Ford
  6. 6 Remember when you encountered code blocks for the first

    time?
  7. 6 Remember when you encountered code blocks for the first

    time? Remember how they were confusing at first?
  8. 6 Remember when you encountered code blocks for the first

    time? Remember how they were confusing at first? But you persevered and mastered them.
  9. 6 Remember when you encountered code blocks for the first

    time? Remember how they were confusing at first? But you persevered and mastered them. Was it worth the effort?
  10. 6 Remember when you encountered code blocks for the first

    time? Remember how they were confusing at first? But you persevered and mastered them. Was it worth the effort? I thought you’d say that.
  11. 7 Lambdas are the next step in that progression.

  12. 8 But it’s not idiomatic Ruby!

  13. 8 But the benefits of using lambdas are so compelling

    that they justify deviating from idiomatic Ruby, or even changing it. But it’s not idiomatic Ruby!
  14. Benefits of Lambdas •Simplicity •Extensibility •Productivity •Fun 9

  15. 10 Unnecessary complexity is our enemy.

  16. 11 As software developers, we strive to maximize the ratio:

    Functionality Complexity
  17. Why Do We Use Local Variables? 12

  18. Why Do We Use Local Variables? 12 • To limit

    their scope. What is the value of that?
  19. Why Do We Use Local Variables? 12 • To limit

    their scope. What is the value of that? • Does it improve the simplicity of the code?
  20. Why Do We Use Local Variables? 12 • To limit

    their scope. What is the value of that? • Does it improve the reliability of the code? • Does it improve the simplicity of the code?
  21. 13 If locality is so important and useful for data,

    why don’t we use it more for code?
  22. 13 If locality is so important and useful for data,

    why don’t we use it more for code? We do have classes…
  23. 13 If locality is so important and useful for data,

    why don’t we use it more for code? We do have classes… …but often so many methods…
  24. 13 If locality is so important and useful for data,

    why don’t we use it more for code? We do have classes… …but often so many methods… …that they need further organizing.
  25. 14 One Measure of Complexity: The Number of Possible Paths

    of Interaction Having n instance methods means n * (n-1) possible call paths from one instance method to another
  26. 15 If only we could define method-like things that were

    nested inside a method, and local to it...
  27. We Can! 16 We can use lambdas as local nested

    functions: def integrated_result fetch_type_1_data = -> do # ... end fetch_type_2_data = -> do # ... end integrate_data = ->(data_1, data_2) do # ...digest and return data end integrate_data.(fetch_type_1_data.(), fetch_type_2_data.()) end
  28. We Can! 16 We can use lambdas as local nested

    functions: Notice anything interesting about the structure? def integrated_result fetch_type_1_data = -> do # ... end fetch_type_2_data = -> do # ... end integrate_data = ->(data_1, data_2) do # ...digest and return data end integrate_data.(fetch_type_1_data.(), fetch_type_2_data.()) end
  29. 17 A Method with Nested Lambdas Can Easily Be Converted

    to a Class When we write our methods with nested lambdas (as needed), converting the method into a small class is trivially easy. We’ll want to do this if the method becomes too complex. class IntegratedResult private def fetch_type_1_data # ... end private def fetch_type_2_data # ... end private def integrate_data(data_1, data_2) # ...digest and return data end def run integrate_data(fetch_type_1_data(), fetch_type_2_data()) end end
  30. 18 In the following example, format refers to a lambda

    that is called multiple times to provide consistent formatting defined in only 1 place. Lambdas as Nested Functions: Formatters # Returns a multiline string like this: # # Start Time : 2019-04-09 17:50:16 +0800 # End Time : 2019-04-09 20:20:16 +0800 # Duration : 2.5 def report_times times_str = '' format = ->(caption, value) do "%-11.11s: %s\n" % [caption, value] end times_str << format.("Start Time", times[:start]) times_str << format.("End Time", times[:end]) times_str << format.("Duration", times[:duration_hr]) times_str << "\n\n" end
  31. 19 You can implement rich functionality using hashes whose values

    are lambdas. This code is used by the rexe utility to offer a wide variety of output formats, extremely simply: Lambdas in Behavior Lookups Example: Formatters def formatters @formatters ||= { amazing_print: ->(obj) { obj.ai << "\n" }, inspect: ->(obj) { obj.inspect + "\n" }, json: ->(obj) { obj.to_json }, marshal: ->(obj) { Marshal.dump(obj) }, none: ->(_obj) { nil }, pretty_json: ->(obj) { JSON.pretty_generate(obj) }, pretty_print: ->(obj) { obj.pretty_inspect }, puts: ->(obj) { sio = StringIO.new; sio.puts(obj); sio.string } to_s: ->(obj) { obj.to_s + "\n" }, yaml: ->(obj) { obj.to_yaml }, } end
  32. 20 Similarly for parsers: Lambdas in Behavior Lookups Example: Parsers

    def input_parsers @input_parsers ||= { json: ->(string) { JSON.parse(string) }, marshal: ->(string) { Marshal.load(string) }, none: ->(string) { string }, yaml: ->(string) { YAML.load(string) }, } end And they are used like this: private def init_parser_and_formatters @input_parser = lookups.input_parsers[options.input_format] @output_formatter = lookups.formatters[options.output_format] @log_formatter = lookups.formatters[options.log_format] end
  33. Lambdas and Threads 21 Packaging code in lambdas is a

    very nice fit for the use of threads: fetch_type_1_data = -> { `uptime` } fetch_type_2_data = -> { `whoami` } integrate_data = ->(f1, f2) { puts f1; puts f2 } type_1_data, type_2_data = [ Thread.new { fetch_type_1_data.() }, Thread.new { fetch_type_2_data.() }, ].map(&:value) integrate_data.(type_1_data, type_2_data) # Outputs: # 16:17 up 6 days, 16:37, 5 users, load averages: 2.79 4.13 5.64 # kbennett
  34. 22 Lambda Syntax The simplest lambda takes no parameters and

    returns nothing, and is shown below. In Ruby versions <= 1.8: In Ruby versions >= 1.9, the "stabby lambda" syntax is added: lambda {} lambda do end -> {} -> do end
  35. 23 In Ruby versions <= 1.8, parameters are specified the

    same way as in a code block: Lambda Syntax lambda { |param1, param2| } lambda do |param1, param2| end
  36. 23 In Ruby versions <= 1.8, parameters are specified the

    same way as in a code block: Lambda Syntax lambda { |param1, param2| } lambda do |param1, param2| end In the "stabby lambda" alternate syntax for Ruby versions >= 1.9, the parameter syntax is identical to method syntax: ->(param1, param2) {} ->(param1, param2) do end
  37. 24 Lambdas are Assignable You can assign a lambda to

    a variable… greeter = ->(name) { "Hello, #{name}!" } # all Ruby Versions: greeter.call('Juan') greeter['Juan'] # Ruby versions >= 1.9 greeter.('Juan') # All produce: "Hello, Juan!" …and then call it:
  38. 25 Lambdas are Closures Local variables defined in the scope

    in which a lambda is created will be accessible to those lambdas. This can be very helpful: n = 15 # Create the lambda and call it immediately: -> { puts n }.() # 15
  39. 26 However, this can be bad if there is a

    variable of the same name that you did not intend to use: Lambdas are Closures n = 15 -> { n = "I just overwrote n." }.() puts n # I just overwrote n.
  40. 27 Lambda Locals However, it is possible to define variables

    as local so that they do not override variables of the same name defined outside of the lambda: n = 15 ->(;n) { n = 'I did NOT overwrite n.' }.() puts n # still 15
  41. 28 Bindings provide further opportunity and risk of modifying variables

    external to the lambda on which other code may rely. This risk is especially great if more than one lambda shares the same binding. Lambdas and Bindings name = 'Joe' f = -> { puts "Name is #{name}" } f.() # 'Name is Joe' f.binding.eval("name = 'Anil'") f.() # 'Name is Anil'
  42. 29 Using the lambda's [] alias for the 'call' method,

    we can implement a multilevel collection accessor that looks like the array and hash [] method: A Collection Accessor Lambda (See https://github.com/keithrbennett/trick_bag/blob/master/lib/trick_bag/collections/collection_access.rb) collection = [ 'a', { 'color' => 'yellow', 'length' => 30, }, [nil, 'I am a string inside an array', 75] ] require 'trick_bag' accessor = TrickBag::CollectionAccess.accessor(collection) puts accessor['1.color'] # yellow puts accessor['2.2'] # 75
  43. 30 Private Methods Aren’t Really Private They can be accessed

    using the send method: class ClassWithPrivateMethod private def my_private_method puts "Hey! You're invading my privacy!" end end ClassWithPrivateMethod.new.send(:my_private_method) # --> Hey! You're invading my privacy.
  44. 31 Lambdas Local to a Method Really Are Private How

    could you possibly access my_local_lambda? It is a local variable whose lifetime is limited to that of the method in which it is created. class ClassWithLocalLambda def foo my_local_lambda = -> do puts "You can't find me." end # ... end end
  45. 32 Self Invoking Anonymous Functions Although we normally call lambdas

    via variables or parameters that refer to them, there's nothing to prevent us from calling them directly: -> do source_dir_root = File.join(File.dirname(__FILE__), 'my_gem') all_files_spec = File.join(source_dir_root, '**', '*.rb') Dir[all_files_spec].each { |file| require file } end.()
  46. 32 Self Invoking Anonymous Functions Although we normally call lambdas

    via variables or parameters that refer to them, there's nothing to prevent us from calling them directly: This hides the local variables so they are not visible outside the lambda. Coffeescript recommends this technique to prevent scripts from polluting the global namespace. -> do source_dir_root = File.join(File.dirname(__FILE__), 'my_gem') all_files_spec = File.join(source_dir_root, '**', '*.rb') Dir[all_files_spec].each { |file| require file } end.()
  47. 33 Lambdas Are Great Event Handlers event_handler = ->(event) do

    puts "This event occurred: #{event}" end something.add_event_handler(event_handler) # Or, even more concisely, # by eliminating the intermediate variable: something.add_event_handler(->(event) do puts "This event occurred: #{event}" end)
  48. 34 Customizable Behavior in Ruby Using Objects (Polymorphism) class EvenFilter

    def call(n) n.even? end end class OddFilter def call(n) n.odd? end end def filter_one_to_ten(filter) (1..10).select { |n| filter.(n) } end puts filter_one_to_ten(EvenFilter.new).to_s # [2, 4, 6, 8, 10]
  49. 35 Customizable Behavior in Ruby Using Lambdas If we use

    lambdas instead, we can dispense with the ceremony and verbosity of classes. See how much simpler the code is! even_filter = ->(n) { n.even? } odd_filter = ->(n) { n.odd? } def filter_one_to_ten(filter) (1..10).select { |n| filter.(n) } end puts filter_one_to_ten(even_filter).to_s # [2, 4, 6, 8, 10]
  50. 36 Eliminating Duplication See the repetition? Let's separate the logic

    from the data by creating a function that provides the logic and returns a lambda prefilled with the multiplier (data). There are 2 main ways to do this, Partial Application and Currying. doubler = ->(n) { 2 * n } tripler = ->(n) { 3 * n } quadrupler = ->(n) { 4 * n }
  51. 37 Partial Application “Partial application (or partial function application) refers

    to the process of fixing a number of arguments to a function, producing another function of smaller arity.” - Wikipedia Here we have a lambda that fixes (embeds) the factor in the lambda it returns: fn_multiply_by = ->(factor) do ->(n) { factor * n } end tripler = fn_multiply_by.(3) tripler.(123) # => 369
  52. 38 Partial Application This is the same, except it is

    a method and not a lambda that performs the partial application: def fn_multiply_by(factor) ->(n) { factor * n } end tripler = fn_multiply_by(3) tripler.(123) # => 369
  53. 39 The ‘curry’ method returns a lambda that, when called

    with arguments, returns another lambda in which those arguments are prefilled (i.e. no longer need to be passed). Currying multiply_2_numbers = ->(x, y) { x * y } tripler = multiply_2_numbers.curry.(3) tripler.(123) # => 369 # or multiply_2_numbers = ->(x, y) { x * y } currier = multiply_2_numbers.curry tripler = currier.(3) tripler.(123) # => 369
  54. 40 Predicates “An operator or function that returns either true

    or false.” - Wiktionary -> { true } -> { false } -> (n) { n.even? }
  55. 41 Predicates as Filters This method takes a message filter

    as a parameter, defaulting to a filter that returns true for all messages. def get_messages(count, timeout, filter = ->(_message) { true }) messages = [] while messages.size < count message = get_message(timeout) messages << message if filter.(message) end messages end
  56. 42 Code Blocks as Filters Unlike the lambda approach, the

    code block approach is cryptic and not intention-revealing. “block_given” and “yield” are anonymous implementation details, and the parameter list does not reveal that a filter is being passed. def get_messages(count, timeout) messages = [] while messages.size < count message = get_message(timeout) messages << message if (! block_given?) || yield(message) end messages end
  57. 43 Separating Unrelated Concerns The BufferedEnumerable class in the trick_bag

    gem provides the logic for buffering an enumerable, but requires passing it the strategy it needs to fetch the objects. The BufferedEnumerable class can be seen at https://github.com/keithrbennett/trick_bag/blob/master/lib/trick_bag/enumerables/buffered_enumerable.rb. # Creates an instance with lambdas for fetch and fetch notify behaviors. # @param chunk_size the maximum number of objects to be buffered # @param fetcher lambda to be called to fetch to fill the buffer # @param fetch_notifier lambda to be called to when a fetch is done def self.create_with_lambdas(chunk_size, fetcher, fetch_notifier = nil)
  58. 44 Parentheses are Mandatory Unlike Ruby methods, which can be

    called without parentheses, a lambda cannot be called without parentheses, since that would refer to the lambda object itself: 2.1.2 :001 > lam = -> { puts 'hello' } => #<Proc:0x000001022b04f0@(irb):1 (lambda)> 2.1.2 :002 > lam => #<Proc:0x000001022b04f0@(irb):1 (lambda)> 2.1.2 :003 > lam.() hello
  59. 45 The Proc Class: Lambda and non-Lambda Procs

  60. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first.
  61. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first. Instances can be either lambda or non-lambda.
  62. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first. Instances can be either lambda or non-lambda. And naming is hard; a non-lambda Proc is usually referred to as a "proc".
  63. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first. Instances can be either lambda or non-lambda. And naming is hard; a non-lambda Proc is usually referred to as a "proc". But lambdas are Proc’s.
  64. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first. Instances can be either lambda or non-lambda. And naming is hard; a non-lambda Proc is usually referred to as a "proc". But lambdas are Proc’s. So in spoken language, when something is called a Proc, you really don't know which it is.
  65. 45 The Proc Class: Lambda and non-Lambda Procs Ruby's Proc

    class was confusing to me at first. Instances can be either lambda or non-lambda. And naming is hard; a non-lambda Proc is usually referred to as a "proc". But lambdas are Proc’s. So in spoken language, when something is called a Proc, you really don't know which it is. pry(main)> a_proc = proc {} #<Proc:0x00007f97f4944128 (pry):1> pry(main)> a_lambda = -> {} #<Proc:0x00007f97f1280150 (pry):2 (lambda)> pry(main)> [a_proc.class, a_lambda.class].inspect "[Proc, Proc]" pry(main)> [a_proc.lambda?, a_lambda.lambda?].inspect "[false, true]"
  66. 46 Comparing Lambdas and Procs return in Lambdas In Ruby,

    a lambda's return returns from the lambda, and not from the enclosing method or lambda. def foo -> { return }.() puts "still in foo" end # > foo # still in foo
  67. 47 Comparing Lambdas and Procs return in Non-Lambda Procs In

    contrast, a Ruby non-lambda Proc return returns from its enclosing scope: def foo proc { return }.() puts "still in foo" end # > foo # > (no output)
  68. 48 Comparing Lambdas and Procs Arity Checking Lambdas have strict

    arity checking; blocks and non-lambda procs do not. # ------------------------------------ Lambdas two_arg_lambda = ->(a, b) {} two_arg_lambda.(1) # ArgumentError: wrong number of arguments (1 for 2) # ------------------------------------ Procs two_arg_proc = proc { |a, b| } two_arg_proc.(1) # No complaint. # ------------------------------------ Blocks def foo yield('x', 'y') # 2 args passed end foo { |x| } # No complaint foo { |x, y, z| } # No complaint
  69. 49 Lambdas and Procs are Selfless Even though a lambda

    is an instance of class Proc, calling self will not return that instance. Instead, it will return its enclosing object, which, when not explicitly defined in a class (as in irb), is main. This is true for both lambda and non-lambda Procs. # Lambdas: -> { puts self }.() # main # Procs: (proc { puts self }).() # main
  70. 50 Classes Can Be Defined in a Lambda Although classes

    cannot be defined in a method, they can be defined in a lambda. class ClassCreationTester def create_class class C1; end; puts C1 # fails to parse end def self.create_class class C2; end; puts C2 # fails to parse end # This works!: CLASS_CREATOR = -> { class C3; end; puts C3 } def test create_class self.create_class CLASS_CREATOR.call end end ClassCreationTester.new.test
  71. 51 Transform Chains We can use Ruby's Enumerable functionality to

    simplify passing an object through multiple transformations. tripler = ->(n) { 3 * n } squarer = ->(n) { n * n } transfomers = [tripler, squarer] #144 start_val = 4 transfomers.inject(start_val) do |value, transform| transform.(value) end # 144
  72. 52 Methods in RSpec Defining methods in RSpec can be

    problematic, but defining lambdas is simple. describe "#made_contact_with_all_cases_in_days?" do #… let(:create_case_contact) { ->(occurred_at, contact_made) { create(:case_contact, casa_case: casa_case, creator: volunteer, occurred_at: occurred_at, contact_made: contact_made) } context "when volunteer has made recent contact" do it "returns true" do create_case_contact.call(Date.current, true) expect(volunteer.made_contact_with_all_cases_in_days?).to eq(true) end end context "when volunteer has not made recent contact" do it "returns false" do create_case_contact.call(Date.current - 60.days, true) expect(volunteer.made_contact_with_all_cases_in_days?).to eq(false) end end
  73. 53 You can use a lambda where a code block

    is expected by preceding it with &. Using a Lambda Where a Code Block is Expected logger = MyLogger.new # The usual case is to pass a code block like this: logger.info { 'I am inside a block' } # But we can instead adapt a lambda: proclaimer = -> { 'I am inside a lambda' } MyLogger.new.info(&proclaimer)
  74. 54 Using a Method Where a Lambda is Expected You

    can use a method where a lambda is expected using this notation: lambda(&method(:foo)) def foo(words) puts words.join(', ') end fn = lambda(&method(:foo)) fn.(%w(Hello World)) # Hello, World
  75. 55