From: Pit Capitain <pit@...>
Date: 2007-01-24T00:49:44+09:00
Subject: Re: Minor Change Proposal for Classes 'Object' and 'Method'

Robert Dober schrieb:
> On 1/23/07, ara.t.howard@noaa.gov <ara.t.howard@noaa.gov> wrote:
>> 'receiver' makes perfect sense to me.  so does 'this'.
> 
> it does not make sense to me, it is only a potential receiver at the time
> being, the receiver in a Bound Method object is just not a meaningful term.
> In order to receive a message a message must be sent.

To me, the main point of this discussion so far has been whether we 
should call an object a receiver if it only plays the *role* of a 
receiver but hasn't *acted* as a receiver yet. David et al. think this 
would be misleading, others (me included) don't think so. We could go on 
and on and I don't think we'll come to an agreement.

But is it really true, that after

   m = a.method(:x)

the object "a" hasn't acted as a receiver yet? Look at this code:

   class C
     def x
       "x of #{self}"
     end
   end

   a = C.new
   m = a.method(:x)

The method C#x hasn't been executed yet. Let's do it in two ways:

   puts a.x     # => x of #<C:0x2ae912c>
   puts m.call  # => x of #<C:0x2ae912c>

Now we change the implementation of the method:

   class C
     remove_method(:x)
     def x
       "new x of #{self.inspect}"
     end
   end

   puts a.x     # => new x of #<C:0x2ae912c>
   puts m.call  # => x of #<C:0x2ae912c>

The BoundMethod object "m" still uses the old definition. Even after 
removing the method...

   class C
     remove_method(:x)
   end

   puts a.x rescue puts $!  # => undefined method `x' for #<C:0x2ae912c>
   puts m.call              # => x of #<C:0x2ae912c>

...we are still able to execute the old implementation. So, if I look at 
this example, I don't think that

   m.call

is really sending a message. It just executes the implementation it has 
remembered in the context of the original object.

What happens when an object receives a message?

1) Search a method for the message in the object's classes/modules.
2) Execute this method in the context of the object.

If the steps 1) and 2) are separated as in...

   m = a.method(:x)
   m.call

...I would even say that the receiving part has occurred in step 1), 
where the object decides how it wants to react upon the message. In step 
2), the object's role is to execute a given piece of code in its context.

So, I would say that after

   m = a.method(:x)

the object a has at least partly acted as a receiver.

David, could you live with that? :-)

Regards,
Pit