Passing a block to a block


#1

I notice that if you pass a block to a block, you can’t use ‘yield’ to
yield to that block:

$ cat yield_in_block.rb
foo = lambda { |e| puts e }
blk = lambda { |e| yield e }
blk.call(123, &foo)

$ ruby yield_in_block.rb
yield_in_block.rb:2: no block given (LocalJumpError)
from yield_in_block.rb:3
$ ruby19 yield_in_block.rb
yield_in_block.rb:2:in block in <main>': no block given (yield) (LocalJumpError) from yield_in_block.rb:3:incall’
from yield_in_block.rb:3:in `’

What’s the reason for this? Does ‘yield’ only invoke the top-level block
passed into a method?

ruby1.9 is happy but only if I explicitly reference the block to yield.

foo = lambda { |e| puts e }
blk = lambda { |e,&y| y[e] }
blk.call(123, &foo)

Thanks,

Brian.


#2

Brian C. wrote:

I notice that if you pass a block to a block, you can’t use ‘yield’ to
yield to that block:

$ cat yield_in_block.rb
foo = lambda { |e| puts e }
blk = lambda { |e| yield e }
blk.call(123, &foo)

blk is not a block. It is a Proc object or closure.
(Note that it isn’t a Lambda object. Lambda is
for Lisp weenies.)

passed into a method?

ruby1.9 is happy but only if I explicitly reference the block to yield.

foo = lambda { |e| puts e }
blk = lambda { |e,&y| y[e] }
blk.call(123, &foo)

foo = proc{|x| puts x }
==>#Proc:0x02b2ae60@:1(irb)
bar = proc{|x,prc| prc[x] }
==>#Proc:0x02b24ac4@:2(irb)
bar[ 88, foo ]
88
==>nil


#3

William J. wrote:

foo = proc{|x| puts x }
==>#Proc:0x02b2ae60@:1(irb)
bar = proc{|x,prc| prc[x] }
==>#Proc:0x02b24ac4@:2(irb)
bar[ 88, foo ]

Indeed, there’s no problem when you pass them around and invoke them
explicitly.

My question (and I apologise if I didn’t word it clearly) was regarding
the ‘yield’ keyword, to make a callback to a hidden proc which is not
one of the explicit arguments. e.g.

def foo(*a,&b)
yield 123 # similar to b.call(123)
end

pr = Proc.new { |x| puts x }
foo(&pr)

This works fine as shown when passing to a method, but not when passing
to another Proc.