diff --git a/Demo/metaclasses/meta-vladimir.txt b/Demo/metaclasses/meta-vladimir.txt new file mode 100644 index 00000000000..070f457b920 --- /dev/null +++ b/Demo/metaclasses/meta-vladimir.txt @@ -0,0 +1,256 @@ +Subject: Re: The metaclass saga using Python +From: Vladimir Marangozov +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 . We can check this by asking Python: "what is A?" + + >>> A # What is A? + + + 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 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'? + # 'a' is an instance of A + >>> b.__class__ # What is the class of 'b'? + # '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? + + >>> 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? + (,) # 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 . We cannot check this by asking Python, but + if we could, it would have answered: + + >>> M # What is M? + + + 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'? + + + >>> B = M() # 'B' is another instance of M + >>> B # What is 'B'? + + + The metaclass-instances, A and B, are of type 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? + # A is an instance of M + >>> A.__metaclass__ # What is the meta-class of B? + # 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? + + >>> 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? + (,) # 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! + + + +-- + Vladimir MARANGOZOV | Vladimir.Marangozov@inrialpes.fr +http://sirac.inrialpes.fr/~marangoz | tel:(+33-4)76615277 fax:76615252