Restructure comparison dramatically. There is no longer a default

*ordering* between objects; there is only a default equality test
(defined by an object being equal to itself only).  Read the comment
in object.c.  The current implementation never uses a three-way
comparison to compute a rich comparison, but it does use a rich
comparison to compute a three-way comparison.  I'm not quite done
ripping out all the calls to PyObject_Compare/Cmp, or replacing
tp_compare implementations with tp_richcompare implementations;
but much of that has happened (to make most unit tests pass).

The following tests still fail, because I need help deciding
or understanding:

test_codeop -- depends on comparing code objects
test_datetime -- need Tim Peters' opinion
test_marshal -- depends on comparing code objects
test_mutants -- need help understanding it

The problem with test_codeop and test_marshal is this: these tests
compare two different code objects and expect them to be equal.
Is that still a feature we'd like to support?  I've temporarily
removed the comparison and hash code from code objects, so they
use the default (equality by pointer only) comparison.

For the other two tests, run them to see for yourself.
(There may be more failing test with "-u all".)

A general problem with getting lots of these tests to pass is
the reality that for object types that have a natural total ordering,
implementing __cmp__ is much more convenient than implementing
__eq__, __ne__, __lt__, and so on.  Should we go back to allowing
__cmp__ to provide a total ordering?  Should we provide some other
way to implement rich comparison with a single method override?
Alex proposed a __key__() method; I've considered a __richcmp__()
method.  Or perhaps __cmp__() just shouldn't be killed off...

Author: gvanrossum

Diff for: Include/object.h

@@ -379,6 +379,7 @@ PyAPI_FUNC(PyObject *) PyObject_Unicode(PyObject *);
 PyAPI_FUNC(int) PyObject_Compare(PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyObject_RichCompare(PyObject *, PyObject *, int);
 PyAPI_FUNC(int) PyObject_RichCompareBool(PyObject *, PyObject *, int);
+PyAPI_FUNC(PyObject *) Py_CmpToRich(int op, int cmp);
 PyAPI_FUNC(PyObject *) PyObject_GetAttrString(PyObject *, const char *);
 PyAPI_FUNC(int) PyObject_SetAttrString(PyObject *, const char *, PyObject *);
 PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *);

Diff for: Lib/StringIO.py

@@ -116,7 +116,7 @@ def tell(self):
         _complain_ifclosed(self.closed)
         return self.pos
 
-    def read(self, n = -1):
+    def read(self, n=None):
         """Read at most size bytes from the file
         (less if the read hits EOF before obtaining size bytes).
 
@@ -128,6 +128,8 @@ def read(self, n = -1):
         if self.buflist:
             self.buf += ''.join(self.buflist)
             self.buflist = []
+        if n is None:
+            n = -1
         if n < 0:
             newpos = self.len
         else:

Diff for: Lib/UserDict.py

@@ -8,11 +8,16 @@ def __init__(self, dict=None, **kwargs):
         if len(kwargs):
             self.update(kwargs)
     def __repr__(self): return repr(self.data)
-    def __cmp__(self, dict):
+    def __eq__(self, dict):
         if isinstance(dict, UserDict):
-            return cmp(self.data, dict.data)
+            return self.data == dict.data
         else:
-            return cmp(self.data, dict)
+            return self.data == dict
+    def __ne__(self, dict):
+        if isinstance(dict, UserDict):
+            return self.data != dict.data
+        else:
+            return self.data != dict
     def __len__(self): return len(self.data)
     def __getitem__(self, key):
         if key in self.data:
@@ -162,11 +167,13 @@ def get(self, key, default=None):
             return default
     def __repr__(self):
         return repr(dict(self.iteritems()))
-    def __cmp__(self, other):
-        if other is None:
-            return 1
+    def __eq__(self, other):
+        if isinstance(other, DictMixin):
+            other = dict(other.iteritems())
+        return dict(self.iteritems()) == other
+    def __ne__(self, other):
         if isinstance(other, DictMixin):
             other = dict(other.iteritems())
-        return cmp(dict(self.iteritems()), other)
+        return dict(self.iteritems()) != other
     def __len__(self):
         return len(self.keys())

Diff for: Lib/UserString.py

@@ -25,11 +25,37 @@ def __float__(self): return float(self.data)
     def __complex__(self): return complex(self.data)
     def __hash__(self): return hash(self.data)
 
-    def __cmp__(self, string):
+    def __eq__(self, string):
         if isinstance(string, UserString):
-            return cmp(self.data, string.data)
+            return self.data == string.data
         else:
-            return cmp(self.data, string)
+            return self.data == string
+    def __ne__(self, string):
+        if isinstance(string, UserString):
+            return self.data != string.data
+        else:
+            return self.data != string
+    def __lt__(self, string):
+        if isinstance(string, UserString):
+            return self.data < string.data
+        else:
+            return self.data < string
+    def __le__(self, string):
+        if isinstance(string, UserString):
+            return self.data <= string.data
+        else:
+            return self.data <= string
+    def __gt__(self, string):
+        if isinstance(string, UserString):
+            return self.data > string.data
+        else:
+            return self.data > string
+    def __ge__(self, string):
+        if isinstance(string, UserString):
+            return self.data >= string.data
+        else:
+            return self.data >= string
+
     def __contains__(self, char):
         return char in self.data
 

Diff for: Lib/ctypes/test/test_simplesubclasses.py

@@ -2,10 +2,10 @@
 from ctypes import *
 
 class MyInt(c_int):
-    def __cmp__(self, other):
+    def __eq__(self, other):
         if type(other) != MyInt:
-            return -1
-        return cmp(self.value, other.value)
+            return NotImplementedError
+        return self.value == other.value
 
 class Test(unittest.TestCase):
 

Diff for: Lib/decimal.py

@@ -706,6 +706,26 @@ def __ne__(self, other):
             return NotImplemented
         return self.__cmp__(other) != 0
 
+    def __lt__(self, other):
+        if not isinstance(other, (Decimal, int, long)):
+            return NotImplemented
+        return self.__cmp__(other) < 0
+
+    def __le__(self, other):
+        if not isinstance(other, (Decimal, int, long)):
+            return NotImplemented
+        return self.__cmp__(other) <= 0
+
+    def __gt__(self, other):
+        if not isinstance(other, (Decimal, int, long)):
+            return NotImplemented
+        return self.__cmp__(other) > 0
+
+    def __ge__(self, other):
+        if not isinstance(other, (Decimal, int, long)):
+            return NotImplemented
+        return self.__cmp__(other) >= 0
+
     def compare(self, other, context=None):
         """Compares one to another.
 
@@ -1894,6 +1914,7 @@ def to_integral(self, rounding=None, context=None):
             ans = self._check_nans(context=context)
             if ans:
                 return ans
+            return self
         if self._exp >= 0:
             return self
         if context is None:

Diff for: Lib/distutils/version.py

@@ -32,7 +32,8 @@
 class Version:
     """Abstract base class for version numbering classes.  Just provides
     constructor (__init__) and reproducer (__repr__), because those
-    seem to be the same for all version numbering classes.
+    seem to be the same for all version numbering classes; and route
+    rich comparisons to __cmp__.
     """
 
     def __init__ (self, vstring=None):
@@ -42,6 +43,42 @@ def __init__ (self, vstring=None):
     def __repr__ (self):
         return "%s ('%s')" % (self.__class__.__name__, str(self))
 
+    def __eq__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c == 0
+
+    def __ne__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c != 0
+
+    def __lt__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c < 0
+
+    def __le__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c <= 0
+
+    def __gt__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c > 0
+
+    def __ge__(self, other):
+        c = self.__cmp__(other)
+        if c is NotImplemented:
+            return c
+        return c >= 0
+
 
 # Interface for version-number classes -- must be implemented
 # by the following classes (the concrete ones -- Version should

Diff for: Lib/doctest.py

@@ -469,11 +469,12 @@ def __repr__(self):
 
 
     # This lets us sort tests by name:
-    def __cmp__(self, other):
+    def __lt__(self, other):
         if not isinstance(other, DocTest):
-            return -1
-        return cmp((self.name, self.filename, self.lineno, id(self)),
-                   (other.name, other.filename, other.lineno, id(other)))
+            return NotImplemented
+        return ((self.name, self.filename, self.lineno, id(self))
+                <
+                (other.name, other.filename, other.lineno, id(other)))
 
 ######################################################################
 ## 3. DocTestParser

Diff for: Lib/optparse.py

@@ -838,13 +838,13 @@ def __str__(self):
 
     __repr__ = _repr
 
-    def __cmp__(self, other):
+    def __eq__(self, other):
         if isinstance(other, Values):
-            return cmp(self.__dict__, other.__dict__)
+            return self.__dict__ == other.__dict__
         elif isinstance(other, types.DictType):
-            return cmp(self.__dict__, other)
+            return self.__dict__ == other
         else:
-            return -1
+            return NotImplemented
 
     def _update_careful(self, dict):
         """

Diff for: Lib/plat-mac/plistlib.py

@@ -374,13 +374,13 @@ def fromBase64(cls, data):
     def asBase64(self, maxlinelength=76):
         return _encodeBase64(self.data, maxlinelength)
 
-    def __cmp__(self, other):
+    def __eq__(self, other):
         if isinstance(other, self.__class__):
-            return cmp(self.data, other.data)
+            return self.data == other.data
         elif isinstance(other, str):
-            return cmp(self.data, other)
+            return self.data == other
         else:
-            return cmp(id(self), id(other))
+            return id(self) == id(other)
 
     def __repr__(self):
         return "%s(%s)" % (self.__class__.__name__, repr(self.data))

Diff for: Lib/pprint.py

@@ -246,7 +246,12 @@ def _safe_repr(object, context, maxlevels, level):
         append = components.append
         level += 1
         saferepr = _safe_repr
-        for k, v in sorted(object.items()):
+        items = object.items()
+        try:
+            items = sorted(items)
+        except TypeError:
+            items = sorted(items, key=lambda (k, v): (str(type(k)), k, v))
+        for k, v in items:
             krepr, kreadable, krecur = saferepr(k, context, maxlevels, level)
             vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level)
             append("%s: %s" % (krepr, vrepr))

Diff for: Lib/sqlite3/test/types.py

@@ -86,6 +86,12 @@ def __cmp__(self, other):
             else:
                 return 1
 
+        def __eq__(self, other):
+            c = self.__cmp__(other)
+            if c is NotImplemented:
+                return c
+            return c == 0
+
         def __conform__(self, protocol):
             if protocol is sqlite.PrepareProtocol:
                 return self.val

Diff for: Lib/test/mapping_tests.py

@@ -60,10 +60,10 @@ def test_read(self):
         for k in self.other:
             self.failIf(k in d)
         #cmp
-        self.assertEqual(cmp(p,p), 0)
-        self.assertEqual(cmp(d,d), 0)
-        self.assertEqual(cmp(p,d), -1)
-        self.assertEqual(cmp(d,p), 1)
+        self.assertEqual(p, p)
+        self.assertEqual(d, d)
+        self.assertNotEqual(p, d)
+        self.assertNotEqual(d, p)
         #__non__zero__
         if p: self.fail("Empty mapping must compare to False")
         if not d: self.fail("Full mapping must compare to True")
@@ -623,26 +623,23 @@ def __repr__(self):
         d = self._full_mapping({1: BadRepr()})
         self.assertRaises(Exc, repr, d)
 
-    def test_le(self):
-        self.assert_(not (self._empty_mapping() < self._empty_mapping()))
-        self.assert_(not (self._full_mapping({1: 2}) < self._full_mapping({1L: 2L})))
+    def test_eq(self):
+        self.assertEqual(self._empty_mapping(), self._empty_mapping())
+        self.assertEqual(self._full_mapping({1: 2}),
+                         self._full_mapping({1L: 2L}))
 
         class Exc(Exception): pass
 
         class BadCmp(object):
             def __eq__(self, other):
                 raise Exc()
             def __hash__(self):
-                return 42
+                return 1
 
         d1 = self._full_mapping({BadCmp(): 1})
         d2 = self._full_mapping({1: 1})
-        try:
-            d1 < d2
-        except Exc:
-            pass
-        else:
-            self.fail("< didn't raise Exc")
+        self.assertRaises(Exc, lambda: BadCmp()==1)
+        self.assertRaises(Exc, lambda: d1==d2)
 
     def test_setdefault(self):
         TestMappingProtocol.test_setdefault(self)

Diff for: Lib/test/output/test_class

@@ -51,16 +51,16 @@ __hex__: ()
 __hash__: ()
 __repr__: ()
 __str__: ()
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
-__cmp__: (1,)
+__eq__: (1,)
+__lt__: (1,)
+__gt__: (1,)
+__ne__: (1,)
+__ne__: (1,)
+__eq__: (1,)
+__gt__: (1,)
+__lt__: (1,)
+__ne__: (1,)
+__ne__: (1,)
 __del__: ()
 __getattr__: ('spam',)
 __setattr__: ('eggs', 'spam, spam, spam and ham')

Diff for: Lib/test/pickletester.py

@@ -65,8 +65,8 @@ def restore(self):
             copy_reg.add_extension(pair[0], pair[1], code)
 
 class C:
-    def __cmp__(self, other):
-        return cmp(self.__dict__, other.__dict__)
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
 
 import __main__
 __main__.C = C

Diff for: Lib/test/test_bisect.py

@@ -174,8 +174,13 @@ def __getitem__(self, ndx):
 
 class CmpErr:
     "Dummy element that always raises an error during comparison"
-    def __cmp__(self, other):
+    def __lt__(self, other):
         raise ZeroDivisionError
+    __gt__ = __lt__
+    __le__ = __lt__
+    __ge__ = __lt__
+    __eq__ = __lt__
+    __ne__ = __lt__
 
 class TestErrorHandling(unittest.TestCase):