<http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html>

I'm hoping this will help uncover the truth.  If anything is unclear,
please report it.  Shed a light.

Sharkin',

would you mind using a print stylesheet so the article can be nicely
printed out?

On Mon, 18 Apr 2005, why the lucky stiff wrote:

The tutorial itself looks good, though the terminology in this area
continues to be a problem.  My understanding is that the most general
term is "singleton class", and that "metaclass" is a special term for
singleton class of a Class object.  (See Pickaxe, 2nd ed., p. 382.)
So, for example, I would rename your Object#metaclass method
#singleton_class, since it applies to all objects (as per RCR 231).

Then there's "virtual class", which I think is the weakest and least
useful term, certainly at a general level.  The Matz paraphrase on
p.382 suggests that virtual-ness is more a matter of implementation
than anything language-level, which is good.  I haven't checked, but
I'm hoping the > 1.8 error messages will cease to refer to "virtual"
classes (e.g., when you try to get at the singleton class of a
Fixnum).

David

I've found that sticking to class instance variables (and thus keeping
things simple -- why do we need another type of variables again?) helps
in making code easier to understand.

class Foo
        @var1 = []
        @var2 = {}
        class << self
                attr_accessor :var1, :var2
        end
end

to get reasonable access to those class instance variables inside an
instance method, and even then you have to do self.class.var1

I only use the term "metaclass" because it is the term predominantly
used in the PickAxe II.  While Dave does interchangibly use "virtual
class" and "singleton class", the only term he uses to generically refer
to the construct is "metaclass".

And I really need to be able to wrap these up in a single word, whilst
still jiving with the PickAxe.

 ># Just defines a class method
 >def class_def name, &blk
 >  class_eval { define_method name, &blk }
 >end

However it actually defines an instance method

require "metaid"

class MyClass
   class_def "class_method" do puts "success" end
end

MyClass.class_method
   #=> undefined method "class_method" for MyClass:Class

MyClass.new.class_method #=> success

"Florian Groß" <flor...@gmail.com> schrieb im Newsbeitrag
news:d4093s$dml$1@sea.gmane.org...

Kind regards

Nice tutorial, I found I learned something from it. I know there is a
chapter in the pickaxe that attempts to explain this, but this seems to be
the best (only?) freely available explanation.

Being somewhat new to the concept of metaprogramming, I can tell you what is
particularly confusing is the use of class << self, how this is like the
root of all singleton behavior, how it differs from class a < b (perhaps
even display how it works inside the interpreter). I wasn't sure what the
difference between the < and the << operator was, so I had to go look it up.

Also the difference between class instance variables and class variables
could use some extra explaining, it seems you're just saying what to do and
what not to do, but not why you can't or shouldn't do it, and why a @@ class
variable is handy.

Thanks,

-Jeff

-Jeff

I personnaly feel it weird I could not realise this whithout the help of the
metaclass manipulation methods _why has added.

In the begining of the page:
"I’ve been keeping these methods in a file called metaid.rb and it’s a start
toward building a little library that can simplify use of metaclasses. Let’s
talk about metaclasses and I advise you to keep metaid.rb at your side. Let’s
talk about metaclasses and I advise you to keep metaid.rb at your side."

"Let’s talk about metaclasses and I advise you to keep metaid.rb at your side."
is said twice.

--
Lionel Thiry

1. Objects are containers for instance variables.
2. Classes are containers for methods and instance variables.

There are more to objects and classes than this, but for the sake of
this discussion, it's useful to whittle it down to this.

  a = Object.new
  a.instance_variable_set( "@name", "Jeff" )

I've created a new object above, storage for instance variables.  I've
added an instance variable to the object.  In doing so, I called the
`instance_variable_set' method.  This method isn't contained in the `a'
object.  It's contained way up the inheritance tree, in the Object class.

Again: the instance variables are stored in the object.  The methods are
stored in a class up the inheritance tree.

   class << a
     def name; @name; end
   end

We're opening a metaclass here.  What is a metaclass?  It's method
storage for an object.  An object can only store instance variables.  
The `name' method has been added to the metaclass (the personal method
storage) for the object `a'.

The most needlessly confusing construct in Ruby is `class << self'.  
You're simply accessing the method storage for whatever object is
currently `self'.

  class Dragon
    class << self; p self; end
  end

Prints: #<Class:Dragon>

Okay, so we're in the metaclass for a class.  But what is that?

It's method storage for class methods.  Normal instance methods are
stored directly in the class.  But class methods are stored in the
metaclass.

  class Dragon
    def self.me; p self; end # This method is stored in the metaclass
    def me; p self; end        # This method is stored in the class
  end

  Dragon.me #=> Dragon
  Dragon.new.me #=> #<Dragon:0x80914e0>

Everyone who uses class methods uses metaclasses.

  class << Dragon
     def roar; "#<CLASS:ROAR>"; end
  end
  Dragon.roar #=> #<CLASS:ROAR>

  d = Dragon.new
  class << d
    def roar; "#<OBJ:ROAR>"; end
  end
  d.roar #=> #<OBJ:ROAR>

I don't really get into this in the article, since I've opted to use the
`metaclass' method and `meta_eval' which are alternate forms of the above.

The < operator is a completely different operator, used strictly for
setting the superclass of a class.

But one handy thing about metaclass (which I believe qualifies them for
the meta- prefix) is that they follow the inheritance tree, simply
remaining one level removed.

  >> Dragon.metaclass
  => #<Class:Dragon>
  >> Dragon.metaclass.superclass
  => #<Class:Object>
  >> Dragon.superclass.metaclass
  => #<Class:Object>

See, an object's metaclass' superclass is the same as the object's
superclass' metaclass.

The `class_def' method is intended to be used to add instance methods
(like the `initialize' I'm adding in Dwemthy's Array):

  class Dragon; end
  Dragon.class_def :initialize do
     @life = 11; @strength = 12
  end

  >> d = Dragon.new
  => #<Dragon:0xb7d571e8 @strength=12, @life=11>

The `meta_def' can be used to add class methods, because of reasons
stated throughout the article and in my response to Jeff.

"It's an important lesson: objects do not store methods, only classes can."

Might be nice to contrast this with prototype based languages like javascript.

Or ProtoRuby ;-)

class ProtoObj
  def initialize
    @methods = {}
  end
  def addMethod(name, &method)
    @methods[name.id2name] = method
  end
  def method_missing(method, *args)
    @methods[method.id2name].call(*args)
  end
end

dog = ProtoObj.new
dog.addMethod(:bark) {
  puts "Bark"

On Mon, 18 Apr 2005, why the lucky stiff wrote:

I don't think there's any case where Dave refers to a singleton class
as a metaclass, except where the object is a Class, but I could be
wrong about that... ?

Anyway, when RCR 231 gets addressed, we'll find out for sure :-)

(I think I misread the p. 382 thing about "virtual".  It does actually
sound like Matz is accepting it as a synonym for "singleton", though I
avoid it because I don't see anything "virtual" about singleton
classes.  They're objects.)

David

I'm not sure what the best thing would be.  I tend to root for the
removal of class variables entirely.  I might even be able to tolerate
#class_attr_* methods, which actually make no sense (since there's
really no more reason to create special methods, in that area, for
Class objects than any other object) but might keep things smoother.

David

It was the other solution I thought for.

--
Lionel Thiry

I would modify Why's metaid library thusly:

  class Object
    def singletonclass
      class << self
        self
      end
    end
  end
  class Class
    def metaclass
      singletonclass
    end
  end

Allowing ...