From: "Thomas B." <tpreal@...>
Date: 2008-09-02T06:34:32+09:00
Subject: Re: Self and Current Class

Pedro Silva wrote:
> I know that Ruby always keeps track of two concepts: self and current
> class.
> 
> The programmer only can access the first one, that tracks the current
> object. I know that self is the default receiver when invoking methods
> and that obviously affects the way Ruby processes the code. Fortunately
> self I understand quite well.
> 
> My doubt comes with the current class concept. I know that when we use
> instance_eval, self is set to the receiver and current class to the
> singleton class, that's why it allows to define singleton methods. I
> would like to undestand how current class is altered by Ruby because
> there's no way to print stuff and see what happens.
> 
> Can anyone enumerate which cases Ruby uses current class and a general
> rule for current class status?
> 
> Pedro.

Hello.

Well, at first I thought that you can always check the current class 
using
class<<self;self;end
but now I see I was wrong. Good I realised it before posting.

In fact, most of the time this is the way to check the current class. 
Inside x.instance_eval{} self is set to x, and the current class is set 
to class<<x;self;end (that is, x's eigenclass), so when you def a method 
there, it will become a method of x (you will be able to call it by 
x.method, no matter if x is a regular object or a class), and the class 
that will hold the method is the x's eigenclass - it will be visible in 
class<<x;instance_methods;end.

But there is an exception from this rule. Inside class declaration:
class K
#here
end
self is set to the class (that is, K), class<<self;self;end is of course 
the class'es eigenclass, but if you def a method now, it will not become 
the method that you can call by K.method, but it will become an instance 
method of the class K, and that means that K was the current class at 
the time of declaring the method, even though it was self at the same 
time.

I guess it works alike inside modules.

So I guess the general rule is: inside module declaration, both self and 
current class are set to the module we're declaring. Outside module 
declarations, current class is set to the eigenclass of self.

I hope this is not a complete mess and rubbish :)

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