Vladimir Marangozov's explanatory message.

1 files changed, 256 insertions, 0 deletions

diff --git a/Demo/metaclasses/meta-vladimir.txt b/Demo/metaclasses/meta-vladimir.txt
new file mode 100644
index 0000000000..070f457b92
--- /dev/null
+++ b/Demo/metaclasses/meta-vladimir.txt
@@ -0,0 +1,256 @@
+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