Blocks, procs and lambdas

An introduction to blocks in Ruby. It stars by looking at the very basics of how to pass and run blocks, arguments, return values and the Proc class. It ends with some more advanced usage of blocks, and some weird tricks that you'll probably never use.

Transcript

1. blocks { proc{} && lambda{} } Jon Cairns http://joncairns.com @joonty
2. What are Ruby blocks? • A block in Ruby is a closure in computer science language – it's a block of code
3. What are Ruby blocks? • A block in Ruby is a closure in computer science language – it's a block of code • Ruby is not designed as a primarily functional programming language
4. What are Ruby blocks? • A block in Ruby is a closure in computer science language – it's a block of code • Ruby is not designed as a primarily functional programming language • Ruby methods are not objects, they can't be passed around as variables – we use blocks instead
5. What are Ruby blocks? • A block in Ruby is a closure in computer science language – it's a block of code • Ruby is not designed as a primarily functional programming language • Ruby methods are not objects, they can't be passed around as variables – we use blocks instead my_method = def say_hello puts "hello" end puts my_method.inspect my_method = def say_hello puts "hello" end puts my_method.inspect
6. What are Ruby blocks? my_method = def say_hello puts "hello" end puts my_method.inspect my_method = def say_hello puts "hello" end puts my_method.inspect • A block in Ruby is a closure in computer science language – it's a block of code • Ruby is not designed as a primarily functional programming language • Ruby methods are not objects, they can't be passed around as variables – we use blocks instead #=> nil #=> nil
7. What are Ruby blocks? Used for:
8. What are Ruby blocks? Used for: • Iterating over arrays and other enumerators [1, 2, 3].each do |i| puts i end [1, 2, 3].each do |i| puts i end
9. What are Ruby blocks? Used for: • Iterating over arrays and other enumerators • Storing code as a variable code = Proc.new { puts “hello” } code = Proc.new { puts “hello” } [1, 2, 3].each do |i| puts i end [1, 2, 3].each do |i| puts i end
10. What are Ruby blocks? Used for: • Iterating over arrays and other enumerators • Storing code as a variable • Callbacks code = Proc.new { puts “hello” } code = Proc.new { puts “hello” } HTTP.get(uri) do |response| puts response.headers end HTTP.get(uri) do |response| puts response.headers end [1, 2, 3].each do |i| puts i end [1, 2, 3].each do |i| puts i end
11. Block syntax [1, 2, 3].each { |i| puts i } [1, 2, 3].each { |i| puts i } Braces:
12. Block syntax [1, 2, 3].each { |i| puts i } [1, 2, 3].each { |i| puts i } [1, 2, 3].each do |i| puts i end [1, 2, 3].each do |i| puts i end Braces: do...end block:
13. Block syntax [1, 2, 3].each { |i| puts i } [1, 2, 3].each { |i| puts i } [1, 2, 3].each do |i| puts i end [1, 2, 3].each do |i| puts i end Braces: do...end block: Functionally equivalent, but style conventions suggest only to use braces for single line blocks only
14. More block examples [1, 2, 3, 4].collect! { |i| i ** 2 } [1, 2, 3, 4].collect! { |i| i ** 2 }
15. More block examples [1, 2, 3, 4].collect! { |i| i ** 2 } [1, 2, 3, 4].collect! { |i| i ** 2 } #=> [1, 4, 9, 16] #=> [1, 4, 9, 16]
16. More block examples clothes = {'long' => ‘johns’, 'hot' => ‘pants’} clothes.each do |key, val| puts “I like #{key} #{val}” end clothes = {'long' => ‘johns’, 'hot' => ‘pants’} clothes.each do |key, val| puts “I like #{key} #{val}” end
17. More block examples clothes = {'long' => ‘johns’, 'hot' => ‘pants’} clothes.each do |key, val| puts “I like #{key} #{val}” end clothes = {'long' => ‘johns’, 'hot' => ‘pants’} clothes.each do |key, val| puts “I like #{key} #{val}” end #=> I like long johns #=> I like hot pants #=> I like long johns #=> I like hot pants
18. Executing blocks A block gets passed to a method, but it isn’t run automatically – the method invokes it with yield
19. Executing blocks A block gets passed to a method, but it isn’t run automatically – the method invokes it with yield def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” }
20. Executing blocks A block gets passed to a method, but it isn’t run automatically – the method invokes it with yield def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” }
21. Executing blocks A block gets passed to a method, but it isn’t run automatically – the method invokes it with yield def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } #=> I’m about to run the block #=> Block block block #=> There, I told you #=> I’m about to run the block #=> Block block block #=> There, I told you
22. Executing blocks A block gets passed to a method, but it isn’t run automatically – the method invokes it with yield def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } def run_my_block puts “I’m about to run the block” yield puts “There, I told you” end run_my_block { puts “Block block block” } Note that the block doesn't appear in the function's parameter list
23. Return values from blocks The return value of a block is also returned by yield, allowing you to do something with the return value in the calling method
24. Return values from blocks The return value of a block is also returned by yield, allowing you to do something with the return value in the calling method def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” } def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” }
25. Return values from blocks The return value of a block is also returned by yield, allowing you to do something with the return value in the calling method def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” } def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” }
26. Return values from blocks The return value of a block is also returned by yield, allowing you to do something with the return value in the calling method def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” } def run_block_and_print_return puts “I’m about to run the block” block_return = yield puts “Block returned: #{block_return}” end run_block_and_print_return { “nothing interesting” } #=> I’m about to run the block #=> Block returned: nothing interesting #=> I’m about to run the block #=> Block returned: nothing interesting
27. Blocks with arguments Blocks can take arguments, which are passed as arguments to yield
28. Blocks with arguments Blocks can take arguments, which are passed as arguments to yield def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end
29. Blocks with arguments Blocks can take arguments, which are passed as arguments to yield def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end
30. Blocks with arguments Blocks can take arguments, which are passed as arguments to yield def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end def give_me_random yield rand(1..10), rand(1..10) end # This block raises the first parameter # to the power of the second give_me_random do |a, b| puts “parameters: #{a}, #{b}” puts a ** b end #=> parameters: 4, 2 #=> 16 #=> parameters: 4, 2 #=> 16
31. Where's the block? What if yield is used when there's no block given?
32. Where's the block? What if yield is used when there's no block given? def i_need_a_block(n) yield n end i_need_a_block 3 def i_need_a_block(n) yield n end i_need_a_block 3
33. Where's the block? What if yield is used when there's no block given? def i_need_a_block(n) yield n end i_need_a_block 3 def i_need_a_block(n) yield n end i_need_a_block 3 #=> no_block.rb:2:in `i_need_a_block': no block given (yield) (LocalJumpError) from no_block.rb:5:in `<main>' #=> no_block.rb:2:in `i_need_a_block': no block given (yield) (LocalJumpError) from no_block.rb:5:in `<main>'
34. Block given? Use block_given? to check whether a block has been passed to the method
35. Block given? Use block_given? to check whether a block has been passed to the method def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" } def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" }
36. Block given? Use block_given? to check whether a block has been passed to the method def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" } def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" }
37. Block given? Use block_given? to check whether a block has been passed to the method def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" } def try_me if block_given? yield else puts "No block given" end end try_me try_me { puts "Block executed" } #=> No block given #=> Block executed #=> No block given #=> Block executed
38. Blocks and scope When a block is defined it remembers the current scope – you can access local variables even when executing the block in a different scope altogether
39. Blocks and scope When a block is defined it remembers the current scope – you can access local variables even when executing the block in a different scope altogether def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end
40. Blocks and scope When a block is defined it remembers the current scope – you can access local variables even when executing the block in a different scope altogether def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end
41. Blocks and scope When a block is defined it remembers the current scope – you can access local variables even when executing the block in a different scope altogether def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end def run_block puts “I can’t see x” unless defined? x yield end x = 10 y = 20 run_block do puts x + y end #=> I can’t see x #=> 30 #=> I can’t see x #=> 30
42. Blocks and scope Even if local variables with the same names are defined in the calling method, the block keeps it’s original scope
43. Blocks and scope Even if local variables with the same names are defined in the calling method, the block keeps it’s original scope def run_block x = 100 y = 200 puts “run_block's x and y: #{x}, #{y}” yield end x = 10 y = 20 run_block do puts x + y end def run_block x = 100 y = 200 puts “run_block's x and y: #{x}, #{y}” yield end x = 10 y = 20 run_block do puts x + y end
44. Blocks and scope Even if local variables with the same names are defined in the calling method, the block keeps it’s original scope def run_block x = 100 y = 200 puts “run_block's x and y: #{x}, #{y}” yield end x = 10 y = 20 run_block do puts x + y end def run_block x = 100 y = 200 puts “run_block's x and y: #{x}, #{y}” yield end x = 10 y = 20 run_block do puts x + y end #=> run_block's x and y: 100, 200 #=> 30 #=> run_block's x and y: 100, 200 #=> 30
45. Blocks and self Blocks don’t just inherit the variables in the current scope, they also inherit the type and provide access to the object where it was defined
46. Blocks and self Blocks don’t just inherit the variables in the current scope, they also inherit the type and provide access to the object where it was defined def run_block yield end run_block { puts self.class } def run_block yield end run_block { puts self.class }
47. Blocks and self Blocks don’t just inherit the variables in the current scope, they also inherit the type and provide access to the object where it was defined def run_block yield end run_block { puts self.class } def run_block yield end run_block { puts self.class } #=> main #=> main
48. Interval!
49. Interval!
50. Blocks as real parameters Blocks can be assigned to method parameters with the ampersand (&) sign
51. Blocks as real parameters Blocks can be assigned to method parameters with the ampersand (&) sign def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" } def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" }
52. Blocks as real parameters Blocks can be assigned to method parameters with the ampersand (&) sign def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" } def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" }
53. Blocks as real parameters Blocks can be assigned to method parameters with the ampersand (&) sign def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" } def give_me_a_block(&my_block) puts my_block.class my_block.call end give_me_a_block { puts "This is a block" } #=> Proc #=> This is a block #=> Proc #=> This is a block
54. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used
55. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10)
56. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) The call method is used to execute a Proc object, and arguments are passed to the block via arguments to call
57. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) The call method is used to execute a Proc object, and arguments are passed to the block via arguments to call
58. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) The call method is used to execute a Proc object, and arguments are passed to the block via arguments to call #=> 25 #=> 100 #=> 25 #=> 100
59. What's a Proc? A Proc object is a block that can be assigned as a variable, allowing it to be re-used square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) square = Proc.new do |n| n ** 2 end puts square.call(5) puts square.call(10) The call method is used to execute a Proc object, and arguments are passed to the block via arguments to call You can also create Proc objects with the proc method #=> 25 #=> 100 #=> 25 #=> 100
60. Pass the proc You could enforce the passing of a Proc object instead of a block, but that's just not Ruby™
61. Pass the proc You could enforce the passing of a Proc object instead of a block, but that's just not Ruby™ def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end) def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end)
62. Pass the proc You could enforce the passing of a Proc object instead of a block, but that's just not Ruby™ def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end) def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end)
63. Pass the proc You could enforce the passing of a Proc object instead of a block, but that's just not Ruby™ def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end) def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end)
64. Pass the proc You could enforce the passing of a Proc object instead of a block, but that's just not Ruby™ def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end) def give_me_random(a_proc) a_proc.call(rand(1..10), rand(1..10)) end puts give_me_random(Proc.new do |a, b| puts “a: #{a}, b: #{b}” puts a ** b end) #=> a: 7, b: 4 #=> 2401 #=> a: 7, b: 4 #=> 2401
65. When to use Procs Useful for re-using blocks but also for allowing multiple blocks to be passed to a method, for callbacks
66. When to use Procs Useful for re-using blocks but also for allowing multiple blocks to be passed to a method, for callbacks def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" }) def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" })
67. When to use Procs Useful for re-using blocks but also for allowing multiple blocks to be passed to a method, for callbacks def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" }) def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" })
68. When to use Procs Useful for re-using blocks but also for allowing multiple blocks to be passed to a method, for callbacks def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" }) def run_callbacks(procs) procs[:before].call puts "Doing my thing" procs[:after].call end run_callbacks(:before => Proc.new { puts "Executing before callback" }, :after => Proc.new { puts "Executing after callback" }) #=> Executing before callback #=> Doing my thing #=> Executing after callback #=> Executing before callback #=> Doing my thing #=> Executing after callback
69. What's a lambda? lambda is a method (on the Kernel module) that creates a Proc object with a block
70. What's a lambda? lambda is a method (on the Kernel module) that creates a Proc object with a block puts lambda {}.class #=> Proc puts lambda {}.class #=> Proc
71. What's a lambda? lambda is a method (on the Kernel module) that creates a Proc object with a block puts lambda {}.class #=> Proc puts lambda {}.class #=> Proc my_proc = lambda do |x| puts “Called with #{x}” end my_proc.call 10 #=> Called with 10 my_proc = lambda do |x| puts “Called with #{x}” end my_proc.call 10 #=> Called with 10
72. What's a lambda? lambda is a method (on the Kernel module) that creates a Proc object with a block puts lambda {}.class #=> Proc puts lambda {}.class #=> Proc In most things, using lambda is equivalent to using Proc.new my_proc = lambda do |x| puts “Called with #{x}” end my_proc.call 10 #=> Called with 10 my_proc = lambda do |x| puts “Called with #{x}” end my_proc.call 10 #=> Called with 10
73. Lambdas in real life Anyone use Active Record? Use lambdas to define scopes
74. Lambdas in real life Anyone use Active Record? Use lambdas to define scopes class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago
75. Lambdas in real life Anyone use Active Record? Use lambdas to define scopes class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago
76. Lambdas in real life Anyone use Active Record? Use lambdas to define scopes class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago class User < ActiveRecord::Base attr_accessible :name, :email scope :created_before, lambda do |at| where(“created_at < ?”, at) end end #... User.created_before 3.days_ago
77. Proc.new !== lambda Even though lambda returns a Proc object, there are two differences between lambda procs and Proc.new procs
78. Proc.new !== lambda Even though lambda returns a Proc object, there are two differences between lambda procs and Proc.new procs 1. Lambdas check the number of parameters passed to it
79. Proc.new !== lambda Even though lambda returns a Proc object, there are two differences between lambda procs and Proc.new procs 1. Lambdas check the number of parameters passed to it 2. Return statements in lambdas return only from the block, and other blocks return from the calling method
80. Lambdas check parameters A lambda proc must have the required number of parameters passed to it, whereas a standard proc is flexible
81. Lambdas check parameters A lambda proc must have the required number of parameters passed to it, whereas a standard proc is flexible a_proc = Proc.new do |x| puts x.inspect end a_proc.call #=> nil a_proc = Proc.new do |x| puts x.inspect end a_proc.call #=> nil
82. Lambdas check parameters A lambda proc must have the required number of parameters passed to it, whereas a standard proc is flexible a_proc = Proc.new do |x| puts x.inspect end a_proc.call #=> nil a_proc = Proc.new do |x| puts x.inspect end a_proc.call #=> nil a_lambda = lambda do |x| puts x.inspect end a_lambda.call #=> args.rb:2:in `block in <main>': wrong number of arguments (0 for 1) (ArgumentError) a_lambda = lambda do |x| puts x.inspect end a_lambda.call #=> args.rb:2:in `block in <main>': wrong number of arguments (0 for 1) (ArgumentError)
83. Lambdas return differently A lambda returns to the context in which they are executing, procs return from the context in which they were defined
84. Lambdas return differently A lambda returns to the context in which they are executing, procs return from the context in which they were defined def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me
85. Lambdas return differently A lambda returns to the context in which they are executing, procs return from the context in which they were defined def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me
86. Lambdas return differently A lambda returns to the context in which they are executing, procs return from the context in which they were defined def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_lambda l = lambda do return "Now you see me" end l.call return "Now you don't!" end puts return_lambda # => Now you don't! def return_lambda l = lambda do return "Now you see me" end l.call return "Now you don't!" end puts return_lambda # => Now you don't!
87. Lambdas return differently A lambda returns to the context in which they are executing, procs return from the context in which they were defined def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_proc p = Proc.new do return "Now you see me" end p.call return "Now you don't!" end puts return_proc # => Now you see me def return_lambda l = lambda do return "Now you see me" end l.call return "Now you don't!" end puts return_lambda # => Now you don't! def return_lambda l = lambda do return "Now you see me" end l.call return "Now you don't!" end puts return_lambda # => Now you don't!
88. Checking for lambdaness The Proc class has a lambda? method which tests the proc object for the behaviour of lambdas
89. Checking for lambdaness The Proc class has a lambda? method which tests the proc object for the behaviour of lambdas a_proc = proc {} puts a_proc.lambda? a_proc = proc {} puts a_proc.lambda? If true then you know that argument handling is strict
90. Checking for lambdaness The Proc class has a lambda? method which tests the proc object for the behaviour of lambdas a_proc = proc {} puts a_proc.lambda? # => false a_proc = proc {} puts a_proc.lambda? # => false If true then you know that argument handling is strict
91. Checking for lambdaness The Proc class has a lambda? method which tests the proc object for the behaviour of lambdas a_proc = proc {} puts a_proc.lambda? # => false a_proc = proc {} puts a_proc.lambda? # => false a_lambda = lambda {} puts a_lambda.lambda? a_lambda = lambda {} puts a_lambda.lambda? If true then you know that argument handling is strict
92. Checking for lambdaness The Proc class has a lambda? method which tests the proc object for the behaviour of lambdas a_proc = proc {} puts a_proc.lambda? # => false a_proc = proc {} puts a_proc.lambda? # => false a_lambda = lambda {} puts a_lambda.lambda? # => true a_lambda = lambda {} puts a_lambda.lambda? # => true If true then you know that argument handling is strict
93. Passing procs as blocks What if you have a proc/lambda, but want to pass it to a method that accepts a block?
94. Passing procs as blocks What if you have a proc/lambda, but want to pass it to a method that accepts a block? def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) Use the ampersand (&) character to pass a proc object as a block, for methods that use yield
95. Passing procs as blocks What if you have a proc/lambda, but want to pass it to a method that accepts a block? def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) Use the ampersand (&) character to pass a proc object as a block, for methods that use yield
96. Passing procs as blocks What if you have a proc/lambda, but want to pass it to a method that accepts a block? def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) def give_me_a_block yield 10 end my_lambda = lambda { |x| puts x } give_me_a_block(&my_lambda) Use the ampersand (&) character to pass a proc object as a block, for methods that use yield #=> 10 #=> 10
97. Now for the fun stuff Fin.
98. Turning methods into procs Ruby methods aren't objects, but we can use the to_proc method on the Symbol class to convert methods to procs...
99. Turning methods into procs Ruby methods aren't objects, but we can use the to_proc method on the Symbol class to convert methods to procs... plus_sym = :+ plus_sym = :+ Create a symbol of the method you want to procify, then call the proc with the object and any parameters
100. Turning methods into procs Ruby methods aren't objects, but we can use the to_proc method on the Symbol class to convert methods to procs... plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc Create a symbol of the method you want to procify, then call the proc with the object and any parameters
101. Turning methods into procs Ruby methods aren't objects, but we can use the to_proc method on the Symbol class to convert methods to procs... plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc puts plus_proc.call 10, 20 plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc puts plus_proc.call 10, 20 Create a symbol of the method you want to procify, then call the proc with the object and any parameters
102. Turning methods into procs Ruby methods aren't objects, but we can use the to_proc method on the Symbol class to convert methods to procs... plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc puts plus_proc.call 10, 20 plus_sym = :+ plus_proc = plus_sym.to_proc #=> Proc puts plus_proc.call 10, 20 Create a symbol of the method you want to procify, then call the proc with the object and any parameters #=> 30 #=> 30
103. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block
104. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block puts (1..100).inject(&:+) puts (1..100).inject(&:+)
105. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block puts (1..100).inject(&:+) puts (1..100).inject(&:+)
106. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end
107. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end Allows you to do some really concise iterations: in this case, :+.to_proc.call(acc, x) is implicitly called on every iteration
108. Turning methods into procs We can use the ampersand operator when passing a symbol, which calls to_proc on that symbol and then passes it as a block puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end puts (1..100).inject(&:+) # which is the same as puts (1..100).inject do |acc, x| acc += x end Allows you to do some really concise iterations: in this case, :+.to_proc.call(acc, x) is implicitly called on every iteration # => 5050 # => 5050 # => 5050 # => 5050
109. Greek Lambdas If you use UTF-8 encoding in your ruby files you can alias the lambda method to the actual Greek letter λ
110. Greek Lambdas If you use UTF-8 encoding in your ruby files you can alias the lambda method to the actual Greek letter λ # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call
111. Greek Lambdas If you use UTF-8 encoding in your ruby files you can alias the lambda method to the actual Greek letter λ # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call
112. Greek Lambdas If you use UTF-8 encoding in your ruby files you can alias the lambda method to the actual Greek letter λ #=> hello #=> hello # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call # encoding: utf-8 module Kernel alias :λ :lambda end λ { puts "hello" }.call
113. Calling procs with [] Why waste precious characters invoking the call method on procs? Use square brackets on the object instead.
114. Calling procs with [] Why waste precious characters invoking the call method on procs? Use square brackets on the object instead. my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20) my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20)
115. Calling procs with [] Why waste precious characters invoking the call method on procs? Use square brackets on the object instead. my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20) my_proc[10, 20] my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20) my_proc[10, 20]
116. Calling procs with [] Why waste precious characters invoking the call method on procs? Use square brackets on the object instead. my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20) my_proc[10, 20] my_proc = proc { |x, y| puts “Given #{x} and #{y}” } my_proc.call(10, 20) my_proc[10, 20] #=> Given 10 and 20 #=> Given 10 and 20 #=> Given 10 and 20 #=> Given 10 and 20
117. Evaluating variables in the proc's scope You can evaluate variables in the scope of a proc by getting the binding and using Kernel#eval
118. Evaluating variables in the proc's scope You can evaluate variables in the scope of a proc by getting the binding and using Kernel#eval def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding) def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding)
119. Evaluating variables in the proc's scope You can evaluate variables in the scope of a proc by getting the binding and using Kernel#eval def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding) def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding)
120. Evaluating variables in the proc's scope You can evaluate variables in the scope of a proc by getting the binding and using Kernel#eval def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding) def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding)
121. Evaluating variables in the proc's scope You can evaluate variables in the scope of a proc by getting the binding and using Kernel#eval def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding) def proc_maker x = 10 y = 20 proc {} end prc = proc_maker puts eval("x + y", prc.binding) #=> 30 #=> 30
122. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected
123. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected my_proc = proc { |a, b, c| a + b + c } my_proc = proc { |a, b, c| a + b + c }
124. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1]
125. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc
126. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc puts curried[2, 3] my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc puts curried[2, 3]
127. Proc curry Procs can be “curried” - this allows arguments to be passed at different stages. The proc is executed when enough arguments have been collected my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc puts curried[2, 3] my_proc = proc { |a, b, c| a + b + c } curried = my_proc.curry[1] puts curried.class #=> Proc puts curried[2, 3] #=> 6 #=> 6
128. Passing blocks to blocks Can we pass a block to a block?
129. Passing blocks to blocks Can we pass a block to a block? def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end
130. Passing blocks to blocks Can we pass a block to a block? def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end
131. Passing blocks to blocks Can we pass a block to a block? def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end def block_to_yield yield() do puts "Trying to pass a block to a block" end end block_to_yield do yield end #=> yield.rb:3: syntax error, unexpected keyword_do #=> yield.rb:6: syntax error, unexpected keyword_end, expecting $end #=> yield.rb:3: syntax error, unexpected keyword_do #=> yield.rb:6: syntax error, unexpected keyword_end, expecting $end
132. Passing blocks to blocks You can do it by turning the blocks into procs and calling them
133. Passing blocks to blocks You can do it by turning the blocks into procs and calling them def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end
134. Passing blocks to blocks You can do it by turning the blocks into procs and calling them def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end
135. Passing blocks to blocks You can do it by turning the blocks into procs and calling them def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end
136. Passing blocks to blocks You can do it by turning the blocks into procs and calling them def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end def block_to_yield(&blk) puts "Starting block_to_yield()" blk.call do puts "I'm a block in a block!" end puts "Ending block_to_yield()" end block_to_yield do |&blk| puts "Starting outer block" blk.call end #=> Starting block_to_yield() #=> Starting outer block #=> I'm a block in a block! #=> Ending block_to_yield() #=> Starting block_to_yield() #=> Starting outer block #=> I'm a block in a block! #=> Ending block_to_yield()
137. So I leave you with this def omg(&a) a.call do |&c| 'ke bi' + c.call do |&e| 'cks a' + e.call + 'an' end + ' lie' end end best_var_ever = omg do |&b| 'I li' + b.call do |&d| 'g blo' + d.call do 'nd I c' end + 'not' end end puts best_var_ever def omg(&a) a.call do |&c| 'ke bi' + c.call do |&e| 'cks a' + e.call + 'an' end + ' lie' end end best_var_ever = omg do |&b| 'I li' + b.call do |&d| 'g blo' + d.call do 'nd I c' end + 'not' end end puts best_var_ever
138. So I leave you with this def omg(&a) a.call do |&c| 'ke bi' + c.call do |&e| 'cks a' + e.call + 'an' end + ' lie' end end best_var_ever = omg do |&b| 'I li' + b.call do |&d| 'g blo' + d.call do 'nd I c' end + 'not' end end puts best_var_ever def omg(&a) a.call do |&c| 'ke bi' + c.call do |&e| 'cks a' + e.call + 'an' end + ' lie' end end best_var_ever = omg do |&b| 'I li' + b.call do |&d| 'g blo' + d.call do 'nd I c' end + 'not' end end puts best_var_ever #=> I like big blocks and I cannot lie #=> I like big blocks and I cannot lie
139. Got all that? Good Fin.