Re: Ruby Method Signatures (was Re: Multiton in standard library)

On 3/21/07, TRANS <[e-mail]> wrote:
> On 3/21/07, Jos Backus <[e-mail]> wrote:
> > On 3/19/07, TRANS <[e-mail]> wrote:

> > No easy way to do this in Ruby beyond
> >
> >     Trace.begin(arg1, arg2)
> >
> > Instead I'd like to be able to write
> >
> >     Trace.begin(__argv__)
>
> I'm a little confused, What's output of this?
>
> This maybe completely aside, but the above reminds me that with
> 'this', there could be:
>
>   def(a,b)
>     Trace.begin(*this.arguments)
>   end
>
> Basically args irregardless of the the actual signature.

I'm guessing that this is bound to the currently executing method, no?

> As for the signature, it would have to be a special class of object
> that has the qualities of Ruby's arguments -- the ordered list, the
> default params and etc. With that object a few things could be
> queried, such as arity, maybe a list of parameter names, whether it
> has a * parameter or a &block parameter, etc. Importantly it could
> output a string representation or the args (whether with the original
> names or not). Eg.
>
>   def a(x,y)
>     this.signature.to_s  #=>  "x,y" -or- "a1,a2"

This isn't the conventional meaning of signature, which is usually a
type construct describing what the caller needs to know about calling
the method. A method signature usually contains:

   1. The name of the method.
   2. The return type (which in Ruby is always anything)
   3. The type of each argument (again in Ruby always anything).
   4. If needed, an indication of argument optionality.

Note that the caller has no need to know the formal argument names.

So it still seems to me that a Ruby type signature only has the name
of the method (which I missed in my opening post), and something like
the arity, although it needs to be cleaned up in the case of arguments
with default values.

> A bonus would be to use the arguments in place of actual arguments
> when defining a method.
>
>   def foo(x)
>   end
>
>   def bar(*=method(:foo).signature)
>     p x   # or  p a1
>   end
>
>   bar(1)  #=> 1
>
> The *= is needed b/c there has to a special way to indicate that.

I think here that you're really talking about getting at the methods
prototype.  Prototypes are like signatures but often include formal
argument names.  In a way you can think of them as the source code
version of a signature.


-- 
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/