Passing block to another function


#1

I have a function:

def worker( &p_block )

p_block.call( my_data )

end

I have a wrapper function, that I would like to use to call ‘worker’.
But I would like the caller of ‘wrapper’ to be able to specify the block
‘wrapper’ will use. i.e.,

def wrapper( &p_block )

worker{ p_block }
end

I suspect that this is possible, but I can’t seem to nail the syntax.

?

~S


#2

On Tue, Mar 21, 2006 at 04:48:50AM +0900, Shea M. wrote:

‘wrapper’ will use. i.e.,

def wrapper( &p_block )

worker{ p_block }
end

I suspect that this is possible, but I can’t seem to nail the syntax.

def worker(&block)
block.call(data)
end

def wrapper(&block)
worker(&block)
end

marcel


#3

Shea M. wrote:

I suspect that this is possible, but I can’t seem to nail the syntax.

Ok,

The following works, is this the
def worker( p_num, &p_block )
for i in 0…p_num
p_block.call( i )
end
end

def five_times( &p_block )
worker( 5 ){ |x| p_block.call(x) }
end

five_times { |i| puts “#{i}. hello” }

~S


#4

It makes sense once you “wrap” your head around it :wink:

(Also, you might want, if possible, to use yield in worker, as well.
It’s more efficient.)

Yeah, it seems dead obvious now. That is good to know about ‘yield’
being more efficient. I always used the named Proc, as I prefer it
syntactically (and I always mispell yeild :smiley: ). I will start using
yield.

~S


#5

Shea M. wrote:

‘wrapper’ will use. i.e.,

def wrapper( &p_block )

worker{ p_block }
end

I suspect that this is possible, but I can’t seem to nail the syntax.

def wrapper
worker {yield}
end

It makes sense once you “wrap” your head around it :wink:

(Also, you might want, if possible, to use yield in worker, as well.
It’s more efficient.)


#6

Shea M. wrote:

~S

Just found my benchmark to back this assertion up:

$ cat yield-vs-proc.rb
require ‘benchmark’

def outer11(&bl)
inner1(&bl)
end

def outer12(&bl)
inner2(&bl)
end

def outer21
inner1 {yield}
end

def outer22
inner2 {yield}
end

def inner1(&bl)
bl.call
end

def inner2
yield
end

n = 100000

Benchmark.bmbm(10) do |rpt|
rpt.report(“outer11”) do
n.times {outer11{}}
end

rpt.report(“outer12”) do
n.times {outer12{}}
end

rpt.report(“outer21”) do
n.times {outer21{}}
end

rpt.report(“outer22”) do
n.times {outer22{}}
end
end

END

Output:

Rehearsal ---------------------------------------------
outer11 0.890000 0.010000 0.900000 ( 0.894500)
outer12 0.370000 0.000000 0.370000 ( 0.364880)
outer21 0.770000 0.000000 0.770000 ( 0.776638)
outer22 0.170000 0.000000 0.170000 ( 0.163393)
------------------------------------ total: 2.210000sec

            user     system      total        real

outer11 0.490000 0.000000 0.490000 ( 0.491969)
outer12 0.400000 0.000000 0.400000 ( 0.396264)
outer21 0.760000 0.000000 0.760000 ( 0.764508)
outer22 0.160000 0.000000 0.160000 ( 0.161982)