Pit Capitain
1/23/2007 3:50:00 PM
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