@Josh,

It's a question of the mental model, but to my memory even Matz's mental
model does not correspond to yours - i remember seeing a presentation
where he explicitly said that methods were not objects, I can find it
soon hopefully and link it here.

Nonetheless, the book "The Ruby Programming Language" which was 
co-written
by Matz has this to say on the matter:

"Methods are a fundamental part of Ruby's syntax, but they are not
values that Ruby programs can operate on. That is, Ruby's methods are
not objects in the way that strings, numbers, and arrays are. It is
possible, however, to obtain a Method object that represents a given
method, and we can invoke methods indirectly through Method objects."

Also see this thread: http://www.ruby-forum.com/topic/190057

One of the rationale given in the above thread is that the object ids
are different each time you call the 'method' method:

method(:puts).object_id != method(:puts).object_id

John



Josh Cheek wrote in post #960762:
> Disclaimer: I seem to be in a crabby mood this morning. I went back over
> it
> (twice) and tried to take out things that were unfriendly, sorry if I
> missed
> anything.
>
> On Thu, Nov 11, 2010 at 6:10 AM, Y. NOBUOKA
> <nobuoka / r-definition.com>wrote:
>
>> /* obtain the Function structure which wrap the function *func* */
>>  Function *func_obj = obtain_Function( func );
>>
>
> That isn't what you do in Ruby. In Ruby, you don't pass the function (or
> function pointer in this case), you pass a String or Symbol.
>
> So this example is not consistent with what Ruby does, doesn't have any
> explanatory power (that I can see, though I don't write C extensions),
> and
> makes everything more complicated.
>
> Here is an alternative model: In Ruby, everything is an object. Methods
> are
> objects, hence the method class.
> http://ruby-doc.org/core/classes/Method.html But you can't directly
> access
> them, because Ruby doesn't make you use parentheses. So trying to access
> the
> method directly looks to the interpreter like you want to invoke the
> method,
> since that is pretty much always what you want to do. But every now and
> then, you want to actually get the method, and so Ruby gives you a
> getter
> method that knows how to do that, and it's aptly named "method".
>
> In C, that looks something like
>
> #include <stdio.h>
> #include <string.h>
>
> typedef struct {
>   char* name;
>   int (*pointer)( int arg );
> } Method;
>
> int twice(  int arg ) { return arg * 2; }
> int thrice( int arg ) { return arg * 3; }
>
> Method internal_mlist[] = {
>   { "twice"  , twice  },
>   { "thrice" , thrice },
> };
>
> Method* method( char* name ) {
>   int i;
>   for( i = 0 ; i < sizeof(internal_mlist)/sizeof(Method) ; ++i )
>     if( !strcmp( internal_mlist[i].name , name ) )
>       return &internal_mlist[i];
>   return NULL;
> }
>
> int main( ) {
>   method("twice");
>   method("thrice");
>   return 0;
> }
>
> For a longer version that is more in line with my mental model
> https://gist.github.com/672665
>
>
>>
>> I think that Ruby users need not know how a Method object wraps a
>> method, but they should know the fact that a Method object wraps a
>> method and a method is not a object.
>>
>>
> Why? Is that even a Ruby thing? It seems so out of place to me that I
> would
> assume it is an MRI implementation detail. Do the other Rubies do it
> that
> way? If so, is it just for efficiency where they are all objects as soon
> as
> we need them to be, but keep it lazy and don't bother turning them into
> objects until such time as we know we need it?
>
> You guys were talking about a spec earlier, the site is apparently down
> right now, but I downloaded the source from github (
> https://github.com/rubyspec/rubyspec), trying to find something on this.
> Maybe I'm not looking in the right spot (I searched for /\.method[^_s]/)
> but
> I didn't see anything like this in there.
>
>
>
> On Thu, Nov 11, 2010 at 8:59 AM, Brian Candler <b.candler / pobox.com>
> wrote:
>
>>
>> Yes. It's important when you compare "pass by value" or "pass by
>> reference" in other languages. In ruby, everything is "pass by value",
>> and each value is a reference to an object - even integers.
>>
>>
> I think we settled on the phrase "object reference" last time this came
> up.

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