From: dblack@...
Date: 2007-01-24T01:36:10+09:00
Subject: Re: Minor Change Proposal for Classes 'Object' and 'Method'

Hi --

On Wed, 24 Jan 2007, Pit Capitain wrote:

> 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? :-)

If I can send people to you when they ask for an explanation of the
double meaning :-)


David

-- 
Q. What is THE Ruby book for Rails developers?
A. RUBY FOR RAILS by David A. Black (http://www.manning.com/black)
    (See what readers are saying!  http://www.rubypal.com/r4rrevs.pdf)
Q. Where can I get Ruby/Rails on-site training, consulting, coaching?
A. Ruby Power and Light, LLC (http://www.rubypal.com)