Subject: Re: The metaclass saga using Python

From: Vladimir Marangozov <Vladimir.Marangozov@imag.fr>

To: tim_one@email.msn.com (Tim Peters)

Cc: python-list@cwi.nl

Date: Wed, 5 Aug 1998 15:59:06 +0200 (DFT)

[Tim]

> 

> building-on-examples-tends-to-prevent-abstract-thrashing-ly y'rs  - tim

> 

OK, I stand corrected. I understand that anybody's interpretation of

the meta-class concept is likely to be difficult to digest by others.

Here's another try, expressing the same thing, but using the Python

programming model, examples and, perhaps, more popular terms.

1. Classes.

   This is pure Python of today. Sorry about the tutorial, but it is

   meant to illustrate the second part, which is the one we're

   interested in and which will follow the same development scenario.

   Besides, newbies are likely to understand that the discussion is

   affordable even for them :-)

   a) Class definition

      A class is meant to define the common properties of a set of objects.

      A class is a "package" of properties. The assembly of properties

      in a class package is sometimes called a class structure (which isn't

      always appropriate).

      >>> class A:

              attr1 = "Hello"                  # an attribute of A

              def method1(self, *args): pass   # method1 of A

              def method2(self, *args): pass   # method2 of A

      >>>

      So far, we defined the structure of the class A. The class A is

      of type <class>. We can check this by asking Python: "what is A?"

      >>> A                                # What is A?

      <class __main__.A at 2023e360>

   b) Class instantiation

      Creating an object with the properties defined in the class A is

      called instantiation of the class A. After an instantiation of A, we

      obtain a new object, called an instance, which has the properties

      packaged in the class A.

      >>> a = A()                          # 'a' is the 1st instance of A 

      >>> a                                # What is 'a'? 

      <__main__.A instance at 2022b9d0>

      >>> b = A()                          # 'b' is another instance of A

      >>> b                                # What is 'b'?

      <__main__.A instance at 2022b9c0>

      The objects, 'a' and 'b', are of type <instance> and they both have

      the same properties. Note, that 'a' and 'b' are different objects.

      (their adresses differ). This is a bit hard to see, so let's ask Python:

      >>> a == b                           # Is 'a' the same object as 'b'?

      0                                    # No.

      Instance objects have one more special property, indicating the class

      they are an instance of. This property is named __class__.

      >>> a.__class__                      # What is the class of 'a'?

      <class __main__.A at 2023e360>       # 'a' is an instance of A

      >>> b.__class__                      # What is the class of 'b'?

      <class __main__.A at 2023e360>       # 'b' is an instance of A

      >>> a.__class__ == b.__class__       # Is it really the same class A?

      1                                    # Yes.

   c) Class inheritance (class composition and specialization)

      Classes can be defined in terms of other existing classes (and only

      classes! -- don't bug me on this now). Thus, we can compose property

      packages and create new ones. We reuse the property set defined

      in a class by defining a new class, which "inherits" from the former.

      In other words, a class B which inherits from the class A, inherits

      the properties defined in A, or, B inherits the structure of A.

      In the same time, at the definition of the new class B, we can enrich

      the inherited set of properties by adding new ones and/or modify some

      of the inherited properties.

      >>> class B(A):                          # B inherits A's properties

              attr2 = "World"                  # additional attr2

              def method2(self, arg1): pass    # method2 is redefined

              def method3(self, *args): pass   # additional method3

      >>> B                                 # What is B?

      <class __main__.B at 2023e500>

      >>> B == A                            # Is B the same class as A?

      0                                     # No.

      Classes define one special property, indicating whether a class

      inherits the properties of another class. This property is called

      __bases__ and it contains a list (a tuple) of the classes the new

      class inherits from. The classes from which a class is inheriting the

      properties are called superclasses (in Python, we call them also --

      base classes).

      >>> A.__bases__                       # Does A have any superclasses?

      ()                                    # No.

      >>> B.__bases__                       # Does B have any superclasses?

      (<class __main__.A at 2023e360>,)     # Yes. It has one superclass.

      >>> B.__bases__[0] == A               # Is it really the class A?

      1                                     # Yes, it is.

--------

   Congratulations on getting this far! This was the hard part.

   Now, let's continue with the easy one.

--------

2. Meta-classes

   You have to admit, that an anonymous group of Python wizards are

   not satisfied with the property packaging facilities presented above.

   They say, that the Real-World bugs them with problems that cannot be

   modelled successfully with classes. Or, that the way classes are

   implemented in Python and the way classes and instances behave at

   runtime isn't always appropriate for reproducing the Real-World's

   behavior in a way that satisfies them.

   Hence, what they want is the following:

      a) leave objects as they are (instances of classes)

      b) leave classes as they are (property packages and object creators)

   BUT, at the same time:

      c) consider classes as being instances of mysterious objects.

      d) label mysterious objects "meta-classes".

   Easy, eh?

   You may ask: "Why on earth do they want to do that?".

   They answer: "Poor soul... Go and see how cruel the Real-World is!".

   You - fuzzy: "OK, will do!"

   And here we go for another round of what I said in section 1 -- Classes.

   However, be warned! The features we're going to talk about aren't fully

   implemented yet, because the Real-World don't let wizards to evaluate

   precisely how cruel it is, so the features are still highly-experimental.

   a) Meta-class definition

      A meta-class is meant to define the common properties of a set of

      classes.  A meta-class is a "package" of properties. The assembly

      of properties in a meta-class package is sometimes called a meta-class

      structure (which isn't always appropriate).

      In Python, a meta-class definition would have looked like this:

      >>> metaclass M:

              attr1 = "Hello"                  # an attribute of M

              def method1(self, *args): pass   # method1 of M

              def method2(self, *args): pass   # method2 of M

      >>>

      So far, we defined the structure of the meta-class M. The meta-class

      M is of type <metaclass>. We cannot check this by asking Python, but

      if we could, it would have answered:

      >>> M                                # What is M?

      <metaclass __main__.M at 2023e4e0>

   b) Meta-class instantiation

      Creating an object with the properties defined in the meta-class M is

      called instantiation of the meta-class M. After an instantiation of M,

      we obtain a new object, called an class, but now it is called also

      a meta-instance, which has the properties packaged in the meta-class M.

      In Python, instantiating a meta-class would have looked like this:

      >>> A = M()                          # 'A' is the 1st instance of M

      >>> A                                # What is 'A'?

      <class __main__.A at 2022b9d0>

      >>> B = M()                          # 'B' is another instance of M

      >>> B                                # What is 'B'?

      <class __main__.B at 2022b9c0>

      The metaclass-instances, A and B, are of type <class> and they both

      have the same properties. Note, that A and B are different objects.

      (their adresses differ). This is a bit hard to see, but if it was

      possible to ask Python, it would have answered:

      >>> A == B                           # Is A the same class as B?

      0                                    # No.

      Class objects have one more special property, indicating the meta-class

      they are an instance of. This property is named __metaclass__.

      >>> A.__metaclass__                  # What is the meta-class of A?

      <metaclass __main__.M at 2023e4e0>   # A is an instance of M

      >>> A.__metaclass__                  # What is the meta-class of B?

      <metaclass __main__.M at 2023e4e0>   # B is an instance of M

      >>> A.__metaclass__ == B.__metaclass__  # Is it the same meta-class M?

      1                                    # Yes.

   c) Meta-class inheritance (meta-class composition and specialization)

      Meta-classes can be defined in terms of other existing meta-classes

      (and only meta-classes!). Thus, we can compose property packages and

      create new ones. We reuse the property set defined in a meta-class by

      defining a new meta-class, which "inherits" from the former.

      In other words, a meta-class N which inherits from the meta-class M,

      inherits the properties defined in M, or, N inherits the structure of M.

      In the same time, at the definition of the new meta-class N, we can

      enrich the inherited set of properties by adding new ones and/or modify

      some of the inherited properties.

      >>> metaclass N(M):                      # N inherits M's properties

              attr2 = "World"                  # additional attr2

              def method2(self, arg1): pass    # method2 is redefined

              def method3(self, *args): pass   # additional method3

      >>> N                              # What is N?

      <metaclass __main__.N at 2023e500>

      >>> N == M                         # Is N the same meta-class as M?

      0                                  # No.

      Meta-classes define one special property, indicating whether a

      meta-class inherits the properties of another meta-class. This property

      is called __metabases__ and it contains a list (a tuple) of the

      meta-classes the new meta-class inherits from. The meta-classes from

      which a meta-class is inheriting the properties are called

      super-meta-classes (in Python, we call them also -- super meta-bases).

      >>> M.__metabases__                # Does M have any supermetaclasses?

      ()                                 # No.

      >>> N.__metabases__                # Does N have any supermetaclasses?

      (<metaclass __main__.M at 2023e360>,)  # Yes. It has a supermetaclass.

      >>> N.__metabases__[0] == M        # Is it really the meta-class M?

      1                                  # Yes, it is.

--------

   Triple congratulations on getting this far!

   Now you know everything about meta-classes and the Real-World!

<unless-wizards-want-meta-classes-be-instances-of-mysterious-objects!>

-- 

       Vladimir MARANGOZOV          | Vladimir.Marangozov@inrialpes.fr

http://sirac.inrialpes.fr/~marangoz | tel:(+33-4)76615277 fax:76615252