1.00 at last!

akuchling · akuchling · commit bec5b362db98 · 2001-12-21T04:39:11.000Z
Describe super() very briefly
A few minor reformattings and wording changes
Set the release date (presumably tomorrow...)
diff --git a/Doc/whatsnew/whatsnew22.tex b/Doc/whatsnew/whatsnew22.tex
@@ -3,16 +3,16 @@
 % $Id$
 
 \title{What's New in Python 2.2}
-\release{0.10}
+\release{1.00}
 \author{A.M. Kuchling}
 \authoraddress{\email{akuchlin@mems-exchange.org}}
 \begin{document}
 \maketitle\tableofcontents
 
 \section{Introduction}
 
-This article explains the new features in Python 2.2.
-The final release of Python 2.2 is planned for December 2001.
+This article explains the new features in Python 2.2, released on
+December 21, 2001.
 
 Python 2.2 can be thought of as the "cleanup release".  There are some
 features such as generators and iterators that are completely new, but
@@ -245,7 +245,7 @@ \subsection{Descriptors}
 stored in the class object.  You might expect there to be special
 syntax for creating such methods (\code{def static f()},
 \code{defstatic f()}, or something like that) but no such syntax has
-been defined yet; that's been left for future versions.
+been defined yet; that's been left for future versions of Python.
 
 More new features, such as slots and properties, are also implemented
 as new kinds of descriptors, and it's not difficult to write a
@@ -260,10 +260,13 @@ \subsection{Descriptors}
 class C(object):
     def f(self, arg1, arg2):
         # The actual function
+        ...
     def pre_f(self):
         # Check preconditions
+        ...
     def post_f(self):
         # Check postconditions
+        ...
 
     f = eiffelmethod(f, pre_f, post_f)
 \end{verbatim}
@@ -276,6 +279,7 @@ \subsection{Descriptors}
 users will just write code on top of the resulting libraries and
 ignore the implementation details.
 
+
 \subsection{Multiple Inheritance: The Diamond Rule}
 
 Multiple inheritance has also been made more useful through changing
@@ -326,9 +330,28 @@ \subsection{Multiple Inheritance: The Diamond Rule}
 
 Following this rule, referring to \method{D.save()} will return
 \method{C.save()}, which is the behaviour we're after.  This lookup
-rule is the same as the one followed by Common Lisp.  
+rule is the same as the one followed by Common Lisp.  A new built-in
+function, \function{super()}, provides a way to get at a class's
+superclasses without having to reimplement Python's algorithm.
+The most commonly used form will be 
+\function{super(\var{class}, \var{obj})}, which returns 
+a bound superclass object (not the actual class object).  This form
+will be used in methods to call a method in the superclass; for
+example, \class{D}'s \method{save()} method would look like this:
+
+\begin{verbatim}
+class D:
+    def save (self):
+	# Call superclass .save()
+        super(D, self).save()
+        # Save D's private information here
+        ...
+\end{verbatim}
 
-% XXX mention super()
+\function{super()} can also return unbound superclass objects
+when called as \function{super(\var{class})} or
+\function{super(\var{class1}, \var{class2})}, but this probably won't
+often be useful.
 
 
 \subsection{Attribute Access}
