How do you define a code block once for reuse?

Question

By code block, I mean:

def callBlock
  yield
  yield
end


callBlock { puts "In the block" } #this is the block

Answer 1

b = lambda { puts "this is the block" }
callBlock &b

or

b.call

with arguments:

def call_block_name
    yield "Dave"
    yield "Mary"
    end

b = lambda { |s| puts "this is block #{s}" }
call_block_names &b

and

b.call("sam")

Answer 2

Use Proc.newto capture a block, e.g.

def callBlocks(*args, &block)
  args.each { |arg| arg.call }
  block.call if block_given?
end

my_proc1 = Proc.new { puts "proc1" }
my_proc2 = Proc.new { puts "proc2" }

callBlocks(my_proc1, my_proc1, my_proc2) {
  puts "block"
}

gives:

proc1
proc1
proc2
block

Want arguments with this?

def callBlocks(*args, &block)
  args.each { |arg| arg.call(1, 2, 3) }
  block.call(4, 5, 6) if block_given?
end

my_proc1 = Proc.new { |a, b, c| puts "proc1 with #{a}, #{b}, #{c}" }
my_proc2 = Proc.new { |a, *dummy| puts "proc2 only needs #{a}" }

callBlocks(my_proc1, my_proc1, my_proc2) { |*abc|
  puts "block with #{abc.join('/')}"
}

gives:

proc1 with 1, 2, 3
proc1 with 1, 2, 3
proc2 only needs 1
block with 4/5/6

Answer 3

• Here's a screencast on how you use blocks in sight
• This is another great blog tutorial.