[ruby-talk:16979] Re: rb_define_class() vs Class.new()

> > The name of a class is _the_ name of that class.
> > I do not understand what you mean with ``just a name''.
> 
> Classes do not need to have names. It's a pure convenience used when
> inspecting objects of that class, and when using things such as
> Class#name.
> 
> When you say
> 
>    class Kero
>       # ...
>    end

*wakes up* ... Who, me?

> it is not an essential part of Ruby's semantics that the class you
> create is named 'Kero'. The class could equally well not have a
> name. All that happens is that a constant is created, called Kero, and
> that constant is set to point to the class object for the class you
> just created. 'Kero' is _not_ the name of the class. 'Kero' is the
> name of the constant that references the class.

I am slowly starting to understand that; it is not clear from
  http://www.ruby-lang.org/en/man-1.4/syntax.html
because it is easy to interpret this in the ``classical'' sense, where
the name is a property of the class itself, say, the instance
variable @name.

Plus, on the C-side in rb_define_class(), an explicit name is given!
(Name of global constant that will refer to ...)

If I ever conceive of a short description to help clarify, I'll tell you.

[snip]

> Creating anonymous classes is basically the same
> 
>   Dave = Class.new
> 
> Here Dave is a constant that points to an anonymous class.

Essentially, you're saying that all classes are anonymous. For the
interpreter that is not a problem at all, of course.

> Now... to the naming issue.
> 
> Ruby classes do not need names: they are only there for output
> purposes. So, matz decided to implement names by cheating: when you
> ask for a class name, Ruby searches through the constants until it
> finds one that references the class, and then uses it. For efficiency,
> it caches the results of doing this in the class object. For anonymous
> objects, the lookup and caching is done when you first try to ask for
> the name. For classes defined using 'class XXX', the caching is done
> when the class is defined.

Hm, ``cheating'' and ``efficiency'' in one paragraph.

OK, I understand enough of what happens and to some extent why it
happens. 

Nevertheless, Dave.name() from the example above produces a non-empty
String, which does not match my idea of ``anonymous''.

Due to the caching and constants not being allowed to change, the
concept of a name of a Class is still useful and usable. Caching,
however, is an implementation detail. The constants ensure that a
Class can have many names, but no two classes have the same name,
still.

So let's close this discussion ;)
Thank you all for your comments, they help a lot to get me into Ruby.

Now where did I leave those other small questions that I have...

Bye,
Kero.

+--- Kero ------------------------------ [e-mail] ---+
|  Don't split your mentality without thinking twice       |
|                          Proud like a God -- Guano Apes  |
+--- M38c ------------------ http://huizen.dds.nl/~kero ---+