Capture variable arguments

Without spending several pages trying to explain myself, I have a need to do something like this:

def method_missing(method_name, *parameters)   @method_name = method_name   @parameters = parameters end

. . . many lifetimes later:

send(@method_name, @parameters)

This sorta works - except that @parameters is, rather than a collection of bare parameters, an array containing them, which the method being called via send() is not expecting. I'm unsure how to pull all the contents out of @parameters and make each an individual bare argument to pass in send(), and very importantly, not pass anything there if @parameters is empty.

Any ideas?

I know this may seem like a weird thing to be trying to do, but it's necessary. Trying to explain why I need to do this would literally take several pages of text. I'm hoping I can avoid the "you shouldn't be trying to do this" argument and just figure out a way to do it. :slight_smile:

-Bill

Without spending several pages trying to explain myself, I have a need to do something like this:

def method_missing(method_name, *parameters)   @method_name = method_name   @parameters = parameters end

. . . many lifetimes later:

send(@method_name, @parameters)

Try send(@method_name, *@parameters)

- donald

That did it. Thanks so much!

Try send(@method_name, *@parameters)

Oh, wow - so * turns an array into a list of arguments? I can't find a reference to this behavior. Pickaxe talks about using * with array arguments, which is the opposite, isn't it?

Can you tell me where I could find more about this usage?

///ark

> Try send(@method_name, *@parameters)

Oh, wow - so * turns an array into a list of arguments? I can't find a reference to this behavior. Pickaxe talks about using * with array arguments, which is the opposite, isn't it?

Can you tell me where I could find more about this usage?

Not specifically, but as I recall, its usage is restricted just to the situation the poster described - when you're trying to pass a list of arguments to a method that allows a variable number of arguments as discrete arguments intstead of list.

- donald

Actually, the * here (David A. Black calls it the "unary unarray operator") is really a feature of Ruby's parallel assignments.

     a, b = 1, 2

Parameter passing in Ruby works just like parallel assignment from the actual parameters to the formals.

Now where does * fit in. You can use it on either the right or left hand side of a parallel assignment, for example:

    a, b = *[1, 2]

sets a to 1 and b to 2. Where

    *a = 1, 2

sets a to [1, 2]

and on the left hand side you can have both one or more variables, and a final "splatted" one.

    a, b, *c = *(1..5)

sets a to 1, b to 2, and c to [3,4,5]

Note that the * implicitly converts what follows to an array if possible, in Ruby 1.8.x this is done using the to_ary method if the object implements it, in Ruby 1.9 a new to_splat method is used which implemented in fewer classes, so fewer values get converted.