Adds concrete generics support

Author: sobolevn

CHANGELOG.md

@@ -7,6 +7,7 @@ We follow Semantic Versions since the `0.1.0` release.
 
 ### Features
 
+- Adds support for concrete generic types like `List[str]` and `Set[int]` #24
 - Adds support for multiple type arguments in `Supports` type #244
 - Adds support for types that have `__instancecheck__` defined #248
 

classes/_registry.py

@@ -0,0 +1,44 @@
+from types import MethodType
+from typing import Callable, Dict, NoReturn, Optional
+
+TypeRegistry = Dict[type, Callable]
+
+
+def choose_registry(  # noqa: WPS211
+    # It has multiple argumnets, but I don't see an easy and performant way
+    # to refactor it: I don't want to create extra structures
+    # and I don't want to create a class with methods.
+    typ: type,
+    is_protocol: bool,
+    delegate: Optional[type],
+    concretes: TypeRegistry,
+    instances: TypeRegistry,
+    protocols: TypeRegistry,
+) -> TypeRegistry:
+    """
+    Returns the appropriate registry to store the passed type.
+
+    It depends on how ``instance`` method is used and also on the type itself.
+    """
+    if is_protocol:
+        return protocols
+
+    is_concrete = (
+        delegate is not None or
+        isinstance(getattr(typ, '__instancecheck__', None), MethodType)
+    )
+    if is_concrete:
+        # This means that this type has `__instancecheck__` defined,
+        # which allows dynamic checks of what `isinstance` of this type.
+        # That's why we also treat this type as a conrete.
+        return concretes
+    return instances
+
+
+def default_implementation(instance, *args, **kwargs) -> NoReturn:
+    """By default raises an exception."""
+    raise NotImplementedError(
+        'Missing matched typeclass instance for type: {0}'.format(
+            type(instance).__qualname__,
+        ),
+    )

classes/_typeclass.py

@@ -114,16 +114,12 @@
 
 See our `official docs <https://classes.readthedocs.io>`_ to learn more!
 """
-
-from abc import get_cache_token
 from functools import _find_impl  # type: ignore  # noqa: WPS450
-from types import MethodType
 from typing import (  # noqa: WPS235
     TYPE_CHECKING,
     Callable,
     Dict,
     Generic,
-    NoReturn,
     Optional,
     Type,
     TypeVar,
@@ -134,6 +130,12 @@
 
 from typing_extensions import TypeGuard, final
 
+from classes._registry import (
+    TypeRegistry,
+    choose_registry,
+    default_implementation,
+)
+
 _InstanceType = TypeVar('_InstanceType')
 _SignatureType = TypeVar('_SignatureType', bound=Callable)
 _AssociatedType = TypeVar('_AssociatedType')
@@ -305,12 +307,17 @@ class _TypeClass(  # noqa: WPS214
     """
 
     __slots__ = (
+        # Str:
         '_signature',
         '_associated_type',
+
+        # Registry:
+        '_concretes',
         '_instances',
         '_protocols',
+
+        # Cache:
         '_dispatch_cache',
-        '_cache_token',
     )
 
     _dispatch_cache: Dict[type, Callable]
@@ -349,16 +356,17 @@ def __init__(
           The only exception is the first argument: it is polymorfic.
 
         """
-        self._instances: Dict[type, Callable] = {}
-        self._protocols: Dict[type, Callable] = {}
-
         # We need this for `repr`:
         self._signature = signature
         self._associated_type = associated_type
 
+        # Registries:
+        self._concretes: TypeRegistry = {}
+        self._instances: TypeRegistry = {}
+        self._protocols: TypeRegistry = {}
+
         # Cache parts:
         self._dispatch_cache = WeakKeyDictionary()  # type: ignore
-        self._cache_token = None
 
     def __call__(
         self,
@@ -410,7 +418,16 @@ def __call__(
         And all typeclasses that match ``Callable[[int, int], int]`` signature
         will typecheck.
         """
-        self._control_abc_cache()
+        # At first, we try all our conrete types,
+        # we don't cache it, because we cannot.
+        # We only have runtime type info: `type([1]) == type(['a'])`.
+        # It might be slow!
+        # Don't add concrete types unless
+        # you are absolutely know what you are doing.
+        impl = self._dispatch_concrete(instance)
+        if impl is not None:
+            return impl(instance, *args, **kwargs)
+
         instance_type = type(instance)
 
         try:
@@ -419,7 +436,7 @@ def __call__(
             impl = self._dispatch(
                 instance,
                 instance_type,
-            ) or self._default_implementation
+            ) or default_implementation
             self._dispatch_cache[instance_type] = impl
         return impl(instance, *args, **kwargs)
 
@@ -481,16 +498,24 @@ def supports(
 
         See also: https://www.python.org/dev/peps/pep-0647
         """
-        self._control_abc_cache()
-
+        # Here we first check that instance is already in the cache
+        # and only then we check concrete types.
+        # Why?
+        # Because if some type is already in the cache,
+        # it means that it is not concrete.
+        # So, this is simply faster.
         instance_type = type(instance)
         if instance_type in self._dispatch_cache:
             return True
 
-        # This only happens when we don't have a cache in place:
+        # We never cache concrete types.
+        if self._dispatch_concrete(instance) is not None:
+            return True
+
+        # This only happens when we don't have a cache in place
+        # and this is not a concrete generic:
         impl = self._dispatch(instance, instance_type)
         if impl is None:
-            self._dispatch_cache[instance_type] = self._default_implementation
             return False
 
         self._dispatch_cache[instance_type] = impl
@@ -541,35 +566,21 @@ def instance(
         isinstance(object(), typ)
 
         def decorator(implementation):
-            container = self._protocols if is_protocol else self._instances
+            container = choose_registry(
+                typ=typ,
+                is_protocol=is_protocol,
+                delegate=delegate,
+                concretes=self._concretes,
+                instances=self._instances,
+                protocols=self._protocols,
+            )
             container[typ] = implementation
 
-            if isinstance(getattr(typ, '__instancecheck__', None), MethodType):
-                # This means that this type has `__instancecheck__` defined,
-                # which allows dynamic checks of what `isinstance` of this type.
-                # That's why we also treat this type as a protocol.
-                self._protocols[typ] = implementation
-
-            if self._cache_token is None:  # pragma: no cover
-                if getattr(typ, '__abstractmethods__', None):
-                    self._cache_token = get_cache_token()
             self._dispatch_cache.clear()
             return implementation
 
         return decorator
 
-    def _control_abc_cache(self) -> None:
-        """
-        Required to drop cache if ``abc`` type got new subtypes in runtime.
-
-        Copied from ``cpython``.
-        """
-        if self._cache_token is not None:
-            current_token = get_cache_token()
-            if self._cache_token != current_token:
-                self._dispatch_cache.clear()
-                self._cache_token = current_token
-
     def _dispatch(self, instance, instance_type: type) -> Optional[Callable]:
         """
         Dispatches a function by its type.
@@ -589,13 +600,11 @@ def _dispatch(self, instance, instance_type: type) -> Optional[Callable]:
 
         return _find_impl(instance_type, self._instances)
 
-    def _default_implementation(self, instance, *args, **kwargs) -> NoReturn:
-        """By default raises an exception."""
-        raise NotImplementedError(
-            'Missing matched typeclass instance for type: {0}'.format(
-                type(instance).__qualname__,
-            ),
-        )
+    def _dispatch_concrete(self, instance) -> Optional[Callable]:
+        for concrete, callback in self._concretes.items():
+            if isinstance(instance, concrete):
+                return callback
+        return None
 
 
 if TYPE_CHECKING:

classes/contrib/mypy/validation/validate_instance_args.py

@@ -19,7 +19,7 @@
 
 @final
 class _ArgValidationContext(NamedTuple):
-    """"""
+    """Context for instance arg validation."""
 
     is_protocol: bool
     delegate: Optional[MypyType]
@@ -30,6 +30,14 @@ def check_type(
     passed_types: TupleType,
     ctx: MethodContext,
 ) -> _ArgValidationContext:
+    """
+    Checks that args to ``.instance`` method are correct.
+
+    We cannot use ``@overload`` on ``.instance`` because ``mypy``
+    does not correctly handle ``ctx.api.fail`` on ``@overload`` items:
+    it then tries new ones, which produce incorrect results.
+    So, that's why we need this custom checker.
+    """
     passed_args = passed_types.items
 
     is_protocol, protocol_check = _check_protocol_arg(passed_args[1], ctx)
@@ -72,10 +80,6 @@ def _check_delegate_arg(
     delegate: MypyType,
     ctx: MethodContext,
 ) -> Tuple[Optional[MypyType], bool]:
-    # TODO: maybe we need to inforce that `delegate` should be
-    # similar to `runtime_type`?
-    # For example, we can ask for subtypes of `runtime_type`.
-    # However, motivation is not clear for now.
     if isinstance(delegate, FunctionLike) and delegate.is_type_obj():
         return delegate.items()[-1].ret_type, True
     return None, True

classes/contrib/mypy/validation/validate_runtime.py

@@ -85,22 +85,18 @@ def check_instance_definition(
             ctx.context,
         )
 
-    return _RuntimeValidationContext(
-        runtime_type=runtime_type,
-        is_protocol=args_check.is_protocol,
-        check_result=all([
-            args_check.check_result,
-            instance_check,
-
-            _check_runtime_protocol(
-                runtime_type, ctx, is_protocol=args_check.is_protocol,
-            ),
-            _check_concrete_generics(
-                runtime_type, instance_type, args_check.delegate, ctx,
-            ),
-            _check_tuple_size(instance_type, ctx),
-        ],
-    ))
+    return _RuntimeValidationContext(runtime_type, args_check.is_protocol, all([
+        args_check.check_result,
+        instance_check,
+
+        _check_runtime_protocol(
+            runtime_type, ctx, is_protocol=args_check.is_protocol,
+        ),
+        _check_concrete_generics(
+            runtime_type, instance_type, args_check.delegate, ctx,
+        ),
+        _check_tuple_size(instance_type, ctx),
+    ]))
 
 
 def _check_runtime_protocol(

docs/pages/api-docs.rst

@@ -1,6 +1,12 @@
 Typeclass
 =========
 
+Caching
+-------
+
+API
+---
+
 Here are the technical docs about ``typeclass`` and how to use it.
 
 .. automodule:: classes._typeclass