passing block to another function

[Shea Martin]

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

 

[Shea Martin]

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

 

[Marcel Molina Jr.]

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.

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

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

marcel

 

[Joel VanderWerf]

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.

def wrapper
worker {yield}
end

It makes sense once you "wrap" your head around it

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

 

[Shea Martin]

It makes sense once you "wrap" your head around it

(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 ). I will start using yield.

~S

 

[Joel VanderWerf]

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 ). I will start using yield.

~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)