Shea_M
March 20, 2006, 8:48pm
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
Shea_M
March 20, 2006, 8:52pm
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
Shea_M
March 20, 2006, 8:53pm
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
Shea_M
March 20, 2006, 9:33pm
4
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
Shea_M
March 20, 2006, 8:55pm
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
(Also, you might want, if possible, to use yield in worker, as well.
It’s more efficient.)
Shea_M
March 20, 2006, 10:47pm
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)