--- /dev/null
+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 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 | Vladimir.Marangozov@inrialpes.fr
+http://sirac.inrialpes.fr/~marangoz | tel:(+33-4)76615277 fax:76615252
projects / python / commitdiff