Mini-PEP: Simplifying numbers.py

* Convert binary methods in Integral to mixin methods
* Remove three-arg __pow__ as a required method
* Make __int__ the root method instead of __long__.

Lib/numbers.py

@@ -283,87 +283,54 @@ class Rational(Real):
 
 
 class Integral(Rational):
-    """Integral adds a conversion to long and the bit-string operations."""
+    """Integral adds a conversion to int and the bit-string operations."""
 
     @abstractmethod
-    def __long__(self):
-        """long(self)"""
+    def __int__(self):
+        """int(self)"""
         raise NotImplementedError
 
     def __index__(self):
         """index(self)"""
-        return long(self)
+        return int(self)
 
-    @abstractmethod
-    def __pow__(self, exponent, modulus=None):
-        """self ** exponent % modulus, but maybe faster.
-
-        Accept the modulus argument if you want to support the
-        3-argument version of pow(). Raise a TypeError if exponent < 0
-        or any argument isn't Integral. Otherwise, just implement the
-        2-argument version described in Complex.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
     def __lshift__(self, other):
-        """self << other"""
-        raise NotImplementedError
+        return int(self) << int(other)
 
-    @abstractmethod
     def __rlshift__(self, other):
-        """other << self"""
-        raise NotImplementedError
+        return int(other) << int(self)
 
-    @abstractmethod
     def __rshift__(self, other):
-        """self >> other"""
-        raise NotImplementedError
+        return int(self) >> int(other)
 
-    @abstractmethod
     def __rrshift__(self, other):
-        """other >> self"""
-        raise NotImplementedError
+        return int(other) >> int(self)
 
-    @abstractmethod
     def __and__(self, other):
-        """self & other"""
-        raise NotImplementedError
+        return int(self) & int(other)
 
-    @abstractmethod
     def __rand__(self, other):
-        """other & self"""
-        raise NotImplementedError
+        return int(other) & int(self)
 
-    @abstractmethod
     def __xor__(self, other):
-        """self ^ other"""
-        raise NotImplementedError
+        return int(self) ^ int(other)
 
-    @abstractmethod
     def __rxor__(self, other):
-        """other ^ self"""
-        raise NotImplementedError
+        return int(other) ^ int(self)
 
-    @abstractmethod
     def __or__(self, other):
-        """self | other"""
-        raise NotImplementedError
+        return int(self) | int(other)
 
-    @abstractmethod
     def __ror__(self, other):
-        """other | self"""
-        raise NotImplementedError
+        return int(other) | int(self)
 
-    @abstractmethod
     def __invert__(self):
-        """~self"""
-        raise NotImplementedError
+        return ~int(self)
 
     # Concrete implementations of Rational and Real abstract methods.
     def __float__(self):
-        """float(self) == float(long(self))"""
-        return float(long(self))
+        """float(self) == float(int(self))"""
+        return float(int(self))
 
     @property
     def numerator(self):