«

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

On Tue, Mar 21, 2006 at 04:48:50AM +0900, Shea Martin wrote:
> 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
--
Marcel Molina Jr. <>

Shea Martin wrote:
> 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.)

--
vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

> 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 Martin wrote:
>
>> 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

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.77663
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.76450
outer22 0.160000 0.000000 0.160000 ( 0.161982)

--
vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407