Forum: Ruby passing block to another function

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
F330a44fdf083a7a30488efc47759f3f?d=identicon&s=25 Shea Martin (Guest)
on 2006-03-20 20:48
(Received via mailing list)
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
Cee0292fffa691f1fb320d5400200e99?d=identicon&s=25 Marcel Molina Jr. (Guest)
on 2006-03-20 20:52
(Received via mailing list)
On Tue, Mar 21, 2006 at 04:48:50AM +0900, Shea Martin 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
F330a44fdf083a7a30488efc47759f3f?d=identicon&s=25 Shea Martin (Guest)
on 2006-03-20 20:53
(Received via mailing list)
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
47b1910084592eb77a032bc7d8d1a84e?d=identicon&s=25 Joel VanderWerf (Guest)
on 2006-03-20 20:55
(Received via mailing list)
Shea Martin 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.)
F330a44fdf083a7a30488efc47759f3f?d=identicon&s=25 Shea Martin (Guest)
on 2006-03-20 21:33
(Received via mailing list)
> 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 :D ).  I will start using
yield.

~S
47b1910084592eb77a032bc7d8d1a84e?d=identicon&s=25 Joel VanderWerf (Guest)
on 2006-03-20 22:47
(Received via mailing list)
Shea Martin 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)
This topic is locked and can not be replied to.