Splat operator and different options to pass a block

ruby-talk
1

Hello,

I'm currently experimenting a bit in Ruby, to get a feeling of how the language works. Out of curiosity, I wanted to have a method which would accept a Proc ( or block/ lambda/ Method ) both passed attached or as an explicit parameter. My idea to realise this was:

   def test( block_as_parameter= nil, &block_attached )
     block = block_attached || block_as_parameter
     block.call
   end

   test { puts "Foo" } #=> Foo
   test( Proc.new { puts "Foo" } ) #=> Foo

So far, so good (I even think that this is the easiest way to achieve said functionality). This works as long as I don't have the splat operator in my parameter list. There are - afaict - two reasons for this:
1.: After the splat operator it is not possible to specify optional parameters (and even if we had the block_as_parameter parameter before the splat, it would take precedence over it, resulting in 2. - also, it would destroy interface consistency).
2.: The block_as_parameter parameter will be filled with one of the parameters which we wanted the splat operator to gather.

My code to solve this problem is as follows:

   def test2( foo, *args, block_as_param, &block_attached )
     block = #this is where the magic happens
       if block_attached
         args << block_as_param
         block_attached
       else
         block_as_param
       end
     p foo
     p args
     block.call
   end

   test2( "FirstParam", "SecondParam" ) { puts "Foo" }
   #=> "FirstParam"
   # ["SecondParam"]
   # Foo
   test2( "FirstParam", "SecondParam", "ThirdParam" ) { puts "Foo" }
   #=> "FirstParam"
   # ["SecondParam", "ThirdParam"]
   # Foo
   test2( "FirstParam", "SecondParam", "ThirdParam", Proc.new { puts "Foo" } )
   #=> "FirstParam"
   # ["SecondParam", "ThirdParam"]
   # Foo

This solution works as I want it to work, so that's good. But now I'm curious: Is there another, easier way to achieve what I want? I'm aware that this has not that many real-life usages, but I think it's an interesting scenario to think about.

Thanks in advance for all your ideas!

P.S.: Tested in Ruby 1.9.3, so I can't tell if this would behave any different in Ruby 1.8.

2

Hi,

First of all, this isn't really a useful technique, because Ruby already
allows you to pass a Proc/Lambda as a block:

prc = proc {|x| puts x}
[1, 2, 3].each(&prc)

In other words: There's simply no need to do this magic inside a method.

Secondly, why do you need a separate parameter for the proc argument?
Why not simply pull it out of the args array?

def test2(foo, *args, &block)
  block ||= args.last
  block[]
end

test2('xyz') {puts 1}
test2('xyz', proc {puts 1})

···

--
Posted via http://www.ruby-forum.com/.

3

Hi,

thanks for your answer. I really appreciate it.

First of all, this isn't really a useful technique, because Ruby already
allows you to pass a Proc/Lambda as a block:

prc = proc {|x| puts x}
[1, 2, 3].each(&prc)

Didn't know that was possible, that's really useful.

Secondly, why do you need a separate parameter for the proc argument?
Why not simply pull it out of the args array?

def test2(foo, *args, &block)
   block ||= args.last
   block
end

test2('xyz') {puts 1}
test2('xyz', proc {puts 1})

D'oh, didn't think of that. Clearly a much nicer solution. I'm coming from Java, that's why I'm sometimes struggling to find these shortcuts on my own - I'm not fully accustomed to this degree of freedom. :wink:

Cheers!