Functional Programming in Ruby

I joined Ruby community when...

Ruby 1.9.3
Rails 3.0

A lightning talk by
Gary Bernhardt from CodeMash 2012

Ruby 3.3.4

a = a#  => nil ruby has no bare words# `<main>': undefined local variable or method `words' for main (NameError)#     from <internal:kernel>:187:in `loop'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>' def method_missing(*args); args.join(' '); end# warning: redefining Object#method_missing may cause infinite loop#  in `join': stack level too deep (SystemStackError)

"ruby" "has" "no" "bare" "words"#  => "rubyhasnobarewords" %q{ruby} "has" 'no' "bare" 'words'#  => "rubyhasnobarewords" "ruby" "has" "no" "bare"\'words'#  => "rubyhasnobarewords"

Agenda

• 🏢 Block
• 🔁 Procs
• 💃 Lambdas
• 🚪 Closures
• 🧙‍♂️ Crazy stuff
• 📑 Summary

📈 Function

🏢 Block

[1, 2, 3, 4].each do |item|  p itemend # 1# 2# 3# 4#  => [1, 2, 3, 4]

Define block

def my_own_block  p 'before'  yield  p 'after'end

How can we run our block?

my_own_block# "before"# in `my_own_block': no block given (yield) (LocalJumpError)#     from (irb):6:in `<main>'#     from <internal:kernel>:187:in `loop'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'

Simple fix

def my_own_block  p 'before'  yield if block_given?  p 'after'end

How can we run our block?

my_own_block# "before"# "after"#  => "after"

How to put something to the block?

my_own_block(5)# `my_own_block': wrong number of arguments (given 1, expected 0) (ArgumentError)#     from (irb):6:in `<main>'#     from <internal:kernel>:187:in `loop'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

How to put something to the block?

my_own_block { 5 }# "before"# "after"#  => "after"

How to put something to the block?

my_own_block { p 5 }# "before"# 5# "after"#  => "after"

🔁 Proc

Block class

def my_block(&block)  p 'before'  p block.class  block.call  p 'after'end

Execute

my_block { p 4 }# "before"# Proc# 4# "after"#  => "after"

Many Procs in one function

def run_proc(first, last)  first.call  last.callend proc1 = Proc.new { p 'first' }proc2 = proc { p 'last' }

Execute

run_proc proc1, proc2# "first"# "last"#  => "last"

🤪 Fun fact

def run_proc  p 'before'  my_proc = Proc.new  my_proc.call  p 'after'end

Execute

run_proc { p 6 }# "before"# in `new': tried to create Proc object without a block (ArgumentError)#     from (irb):3:in `run_proc'#     from (irb):7:in `<main>'#     from <internal:kernel>:187:in `loop'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

🤔 How call Proc object?

Proc with parameter

my_proc = Proc.new do |item|  p "Text: #{item}"end

Execute

my_proc.call 10my_proc.yield 20my_proc.(30)my_proc[40]my_proc === 50

💼 Proc in case

Use proc in case

def check_type(name)  message_type = proc { |name| name.include?('Message') }   case name  when message_type then "It's a message type!"  else    'Other type'  endend check_type('ConversationAdded')# => "Other type"check_type('SingleMessageAdded')# => "It's a message type!"

🪄 One more trick

(4..7) === 5 # => true

☎️ Call method with argument as proc

class User  def initialize(name)    @name = name  end   def say_my_age(age)    puts "I'm #{age} years ago"  endend

user = User.new('Agnieszka') user.say_my_age(15)# I'm 15 years ago#  => nil

Call with call 😉

user = User.new('Agnieszka') :say_my_age.to_proc.call(user, 15)# I'm 15 years ago#  => nil :say_my_age.to_proc.yield(user, 15)# I'm 15 years ago#  => nil

Rubinius implementation

# Returns a Proc object which respond to the given method by sym.def to_proc  # Put sym in the outer enclosure so that this proc can be instance_eval'd.  # If we used self in the block and the block is passed to instance_eval, then  # self becomes the object instance_eval was called on. So to get around this,  # we leave the symbol in sym and use it in the block.  #  sym = self  Proc.new do |*args, &b|    raise ArgumentError, "no receiver given" if args.empty?    args.shift.__send__(sym, *args, &b)  endend

Use our example

# Returns a Proc object which respond to the given method by sym.def to_proc  # Put sym in the outer enclosure so that this proc can be instance_eval'd.  # If we used self in the block and the block is passed to instance_eval, then  # self becomes the object instance_eval was called on. So to get around this,  # we leave the symbol in sym and use it in the block.  #  sym = :say_my_age  Proc.new do |*args, &b|    raise ArgumentError, "no receiver given" if [user, 15].empty?    user.__send__(:say_my_age, *[15], &b)  endend

Call with ===

user = User.new('Agnieszka') :say_my_age.to_proc === user, 15# `loop': (irb):31: syntax error, unexpected ',', expecting end-of-input (SyntaxError)#  :say_my_age.to_proc === user, 15#                               ^ :say_my_age.to_proc.=== user, 15# I'm 15 years ago#  => nil

😮 Call with ===

user = User.new('Agnieszka') (:say_my_age.to_proc.curry(2) === user)[15]# I'm 15 years ago#  => nil (:say_my_age.to_proc.curry(2) === user).call(15)# I'm 15 years ago#  => nil

🍛 Curry

proc_1 = :say_my_age.to_proc.curry(2)proc_2 = proc_1.call(user)proc_2.call(15)# I'm 15 years ago#  => nil proc_1[user][15]# I'm 15 years ago#  => nil

💃 Lambdas

1. Arguments control

my_proc = Proc.new { |item|  p "==#{item}==" }my_lambda = lambda { |item|  p "==#{item}==" } my_proc.arity#  => 1my_lambda.arity#  => 1

Execute

my_proc.call# "===="#  => "====" my_lambda.call# in <top (required)>': wrong number of arguments (given 0, expected 1) (ArgumentError)#   from (irb):6:in `<main>'#   from <internal:kernel>:187:in `loop'#   from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#   from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#   from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

🗄️ Array of arguments

lambda { |*items| }.arity# => -1

New lambda declaration

my_lambda = -> { p 'Is it still working?' }my_lambda.call# "Is it still working?"#  => "Is it still working?"

But ...

my_lambda.class# => Proc my_lambda.lambda?# => true my_lambda = lambda { |item|  p "==#{item}==" }# => #<Proc:0x00007f2ac55ce080 (irb):2 (lambda)>

2. Using with return

def run(proc)  p 'before'  proc.call  p 'after'end

Execute lambda

run lambda { p 'In'; return }# "before"# "In"# "after"#  => "after"

Execute proc

run proc { p 'In'; return }# "before"# "In"# in `block in <top (required)>': unexpected return (LocalJumpError)#     from (irb):14:in `run'#     from (irb):19:in `<main>'#     from <internal:kernel>:187:in `loop'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#     from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

🏝️ Change the context

def change_context  run lambda { p 'In'; return }  run proc { p 'In'; return }end # "before"# "In"# "after"# "before"# "In"#  => nil

🏝️ Change the context

def change_context  run proc { p 'In'; return }  run lambda { p 'In'; return }end # "before"# "In"#  => nil

3. Lambda can return value even if the creation context is gone

def first(closure)  p 'start first'  p "closure: #{closure.call}"  p 'end first'end def second  p 'start second'  p "first return: #{first(lambda { return 'lambda' })}"  p 'end second'end

Execute

second# "start second"# "start first"# "closure: lambda"# "end first"# "first return: end first"# "end second"#  => "end second"

3. Proc after return, finishes all methods (first and second)

def first(closure)  p 'start first'  p "closure: #{closure.call}"  p 'end first'end def second  p 'start second'  p "first return: #{first(proc { return 'proc' })}"  p 'end second'end

Execute

second# "start second"# "start first"#  => "proc"

🚪 Closures

Execute

def run(proc)  proc.callend name = 'Agnieszka'my_proc = proc { p name }run my_proc# "Agnieszka"#  => "Agnieszka"

What happened if the variable was not created before?

my_proc = proc { p last_name }run my_proc# in <top (required)>': undefined local variable or method `last_name' for main (NameError)#  my_proc = proc { p last_name }#                     ^^^^^^^^^#    from (irb):2:in `run'#    from (irb):10:in `<main>'#    from <internal:kernel>:187:in `loop'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

Second try

last_name = "Małaszkiewicz"run my_proc# in <top (required)>': undefined local variable or method `last_name' for main (NameError)# my_proc = proc { p last_name }#                   ^^^^^^^^^#    from (irb):2:in `run'#    from (irb):12:in `<main>'#    from <internal:kernel>:187:in `loop'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/lib/ruby/gems/3.3.0/gems/irb-1.13.1/exe/irb:9:in `<top (required)>'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `load'#    from /home/agnieszka/.rvm/rubies/ruby-3.3.4/bin/irb:25:in `<main>'

🤔 What's going on here?

name = 'Agnieszka'my_proc = proc { p name }name = 'Ula' run my_proc# => ?

Answer

name = 'Agnieszka'my_proc = proc { p name }name = 'Ula' run my_proc"Ula"# => "Ula"

Where can we use this?

Defining function which creates other functions

def multiple(m)  lambda { |n| n * m }end double = multiple(2)triple = multiple(3) double[5] => 10triple[5] => 15

🧙‍♂️ Crazy stuff

🗺️ map(&:name)

🗺️ map(&:name)

[1, 2, 3].map(&:next)#  => [2, 3, 4] [1, 2, 3].map { |item| item.next }#  => [2, 3, 4] [1, 2, 3].map(&:next.to_proc)#  => [2, 3, 4]

🗺️ map(&:name)

my_next = Proc.new { |item| item.next }#  => #<Proc:0x000055acb457fd30 (irb):4> [1, 2, 3].map(&my_next)#  => [2, 3, 4]

🦄 Call map with argument method

[1, 2, 3].map(&:+(2))# in `loop': (irb):1: syntax error, unexpected '(', expecting ')' (SyntaxError)# [1, 2, 3].map(&:+(2))#                  ^ [1, 2, 3].map(&2.method(:+))#  => [3, 4, 5]

2.method(:+)#  => #<Method: Integer#+(_)> 2.method(:+).call(1)#  => 3 [1, 2, 3].map(&2.method(:+))#  => [3, 4, 5]

😲 Other possibilities

[1, 2, 3].to_enum.with_object(2).map(&:+)#  => [3, 4, 5] [1, 2, 3].map(&:+.to_proc.curry(2).call(2))#  => [3, 4, 5]

#️⃣ Hash in map

#️⃣ Hash in map

[:check, :my, :keys].map(&{ my: 2 })#  => [nil, 2, nil] { my: 2 }.to_proc.call(:my)#  => 2

💎 Rubinius implementation

def to_proc  method(:[]).to_procend { my: 2 }.to_proc.call(:my)#  => 2 { my: 2 }[:my]#  => 2

Objects implement to_proc method

[1, 2, 3].map(&:next)#  => [2, 3, 4] [1, 2, 3].map(&2.method(:+))#  => [3, 4, 5] [:check, :my, :keys].map(&{ my: 2 })#  => [nil, 2, nil]

🦓 Passing argument to map

🦓 Passing argument to map

[1, 2, 3].map { |item| item ** 2 }#  => [1, 4, 9] [1, 2, 3].map { _1 ** 2 }#  => [1, 4, 9]

1 + 2

1 + 2

1.+(2)#  => 3 1.send(:+, 2)#  => 3 1.method(:+) === 2#  => 3 :+.to_proc.call(1, 2)#  => 3

🤯

Summary

Types

• 🏢 block + yield
• 🏁 block + &b
• 🔁 Proc.new
• 👨‍💻 proc
• 💃 lambda
• 🤖 method

Where do we use this?

[1, 2, 3].each { |item| p item }[1, 2, 3].each_cons(2).map { |x, y| x + y }[1, 2, 3].map { |item| item.next }[1, 2, 3].inject(0) { |sum, item| sum + item }[1, 2, 3].inject(0, :+) respond_to do |format|  format.html # index.html.erb  format.xml  { render :xml => @items }end

📞 How do we call yield_run or block_run?

def yield_run  yieldend def block_run(&block)  block.callend

The same 😂

block_run { 'my proc' }block_run { p 'my proc' } block_run do  'my proc'end my_proc = lambda { p 'my proc' }block_run &my_proc block_run { my_proc }block_run { my_proc.call }

📦 What do we get?

name = 'Agnieszka'my_proc = lambda do  name = 'Maria'  p nameend my_proc.call # => ?name # => ?

🤨 Answer

name = 'Agnieszka'my_proc = lambda do  name = 'Maria'  p nameend my_proc.call# "Maria"#  => "Maria" name # => "Maria"

🎁 What do we get?

def run  a = 10  yield  yield  p "#{a}"end a = 5run { a += 1 } # => ?a # => ?

😵‍💫 Answer

def run  a = 10  yield  yield  p "#{a}"end a = 5run { a += 1 }# "10"#  => "10"a # => 7

💝 What do we get?

f = proc {|x| x * x }g = proc {|x| x + x } (f >> g).call(2) # => ?(g >> f).call(2) # => ? # g(f(x))# f(g(x))

😵 Answer

f = proc {|x| x * x }g = proc {|x| x + x } (f >> g).call(2) # => 8(g >> f).call(2) # => 16

Links

• Wat lightning talk
• parsel.y
• Why do two strings separated by space concatenate in Ruby?
• Closure in Ruby
• An Introduction to Proc, Lambdas and Closures in Ruby
• Design Patterns in Ruby - Russ Olsen
• Ruby doc
• Functional Programming with Ruby
• Features of Functional Languages
• Ruby Proc doc 2.6

Links

• Rubinius
• Ruby current Proc doc
• Ruby Proc doc 1.9.1
• Ruby Proc doc 1.8.6
• Method#curry
• Ruby map(&:method) syntax - meaning & usage
• Method object
• Functional programming in Ruby
• Iterators in Ruby
• Things you didn't know about Ruby