Subject: Re: The metaclass saga using Python

From: Vladimir Marangozov <[email protected]>

To: [email protected] (Tim Peters)

Cc: [email protected]

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 instanciation

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

called instanciation of the class A. After an instanciation 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 instanciation

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

called instanciation of the meta-class M. After an instanciation 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.__bases__[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 | [email protected]

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