Add SupportsInt etc. and Reversible.

Author: Guido van Rossum

prototyping/test_typing.py

@@ -597,6 +597,31 @@ def get(self, key: str, default=None):
             return default
 
 
+class ProtocolTests(TestCase):
+
+    def test_supports_int(self):
+        assert issubclass(int, typing.SupportsInt)
+        assert not issubclass(str, typing.SupportsInt)
+
+    def test_supports_float(self):
+        assert issubclass(float, typing.SupportsFloat)
+        assert not issubclass(str, typing.SupportsFloat)
+
+    def test_supports_abs(self):
+        assert issubclass(float, typing.SupportsAbs)
+        assert issubclass(int, typing.SupportsAbs)
+        assert not issubclass(str, typing.SupportsAbs)
+
+    def test_supports_round(self):
+        assert issubclass(float, typing.SupportsRound)
+        assert issubclass(int, typing.SupportsRound)
+        assert not issubclass(str, typing.SupportsRound)
+
+    def test_reversible(self):
+        assert issubclass(list, typing.Reversible)
+        assert not issubclass(int, typing.Reversible)
+
+
 class GenericTests(TestCase):
 
     def test_basics(self):

prototyping/typing.py

@@ -38,6 +38,8 @@ class TypingMeta(type):
     __new__) and a nicer repr().
     """
 
+    _is_protocol = False
+
     def __new__(cls, name, bases, namespace, *, _root=False):
         if not _root:
             raise TypeError("Cannot subclass %s" %
@@ -1029,6 +1031,63 @@ def overload(func):
     raise RuntimeError("Overloading is only supported in library stubs")
 
 
+class _Protocol(Generic):
+    """Internal base class for protocol classes.
+
+    This implements a simple-minded structural isinstance check
+    (similar but more general than the one-offs in collections.abc
+    such as Hashable).
+    """
+
+    _is_protocol = True
+
+    @classmethod
+    def __subclasshook__(self, cls):
+        if not self._is_protocol:
+            # No structural checks since this isn't a protocol.
+            return NotImplemented
+
+        if self is _Protocol:
+            # Every class is a subclass of the empty protocol.
+            return True
+
+        # Find all attributes defined in the protocol.
+        attrs = self._get_protocol_attrs()
+
+        for attr in attrs:
+            if not any(attr in d.__dict__ for d in cls.__mro__):
+                return NotImplemented
+        return True
+
+    @classmethod
+    def _get_protocol_attrs(self):
+        # Get all Protocol base classes.
+        protocol_bases = []
+        for c in self.__mro__:
+            if getattr(c, '_is_protocol', False) and c.__name__ != '_Protocol':
+                protocol_bases.append(c)
+
+        # Get attributes included in protocol.
+        attrs = set()
+        for base in protocol_bases:
+            for attr in base.__dict__.keys():
+                # Include attributes not defined in any non-protocol bases.
+                for c in self.__mro__:
+                    if (c is not base and attr in c.__dict__ and
+                            not getattr(c, '_is_protocol', False)):
+                        break
+                else:
+                    if (not attr.startswith('_abc_') and
+                        attr != '__abstractmethods__' and
+                        attr != '_is_protocol' and
+                        attr != '__dict__' and
+                        attr != '_get_protocol_attrs' and
+                        attr != '__module__'):
+                        attrs.add(attr)
+
+        return attrs
+
+
 # Various ABCs mimicking those in collections.abc.
 # A few are simply re-exported for completeness.
 
@@ -1043,6 +1102,41 @@ class Iterator(Iterable, extra=collections.abc.Iterator):
     pass
 
 
+class SupportsInt(_Protocol):
+
+    @abstractmethod
+    def __int__(self) -> int:
+        pass
+
+
+class SupportsFloat(_Protocol):
+
+    @abstractmethod
+    def __float__(self) -> float:
+        pass
+
+
+class SupportsAbs(_Protocol[T]):
+
+    @abstractmethod
+    def __abs__(self) -> T:
+        pass
+
+
+class SupportsRound(_Protocol[T]):
+
+    @abstractmethod
+    def __round__(self, ndigits: int = 0) -> T:
+        pass
+
+
+class Reversible(_Protocol[T]):
+
+    @abstractmethod
+    def __reversed__(self) -> 'Iterator[T]':
+        pass
+
+
 Sized = collections.abc.Sized  # Not generic.