Adds type-test for callbacks

Author: sobolevn

README.md

@@ -32,7 +32,7 @@ Smart, pythonic, ad-hoc, typed polymorphism for Python.
 pip install classes
 ```
 
-You might also want to [configure](https://classes.readthedocs.io/en/latest/pages/container.html#type-safety)
+You also need to [configure](https://classes.readthedocs.io/en/latest/pages/container.html#type-safety)
 `mypy` correctly and install our plugin
 to fix [this existing issue](https://github.com/python/mypy/issues/3157):
 
@@ -43,6 +43,8 @@ plugins =
   classes.contrib.mypy.typeclass_plugin
 ```
 
+**Without this step**, your project will report type-violations here and there.
+
 We also recommend to use the same `mypy` settings [we use](https://github.com/wemake-services/wemake-python-styleguide/blob/master/styles/mypy.toml).
 
 Make sure you know how to get started, [check out our docs](https://classes.readthedocs.io/en/latest/)!

classes/__init__.py

@@ -7,5 +7,4 @@
 so mypy's ``implicit_reexport`` rule will be happy.
 """
 
-from classes.typeclass import TypeClass as TypeClass
 from classes.typeclass import typeclass as typeclass

classes/contrib/mypy/typeclass_plugin.py

@@ -96,13 +96,13 @@ def _filter_out_unified_types(self, type_) -> bool:
 class _TypedDecoratorPlugin(Plugin):
     def get_method_signature_hook(self, fullname: str):
         """Here we fix the calling method types to accept only valid types."""
-        if fullname == 'classes.typeclass.TypeClass.__call__':
+        if fullname == 'classes.typeclass._TypeClass.__call__':
             return _adjust_call_signature
         return None
 
     def get_method_hook(self, fullname: str):
         """Here we adjust the typeclass with new allowed types."""
-        if fullname == 'classes.typeclass.TypeClass.instance':
+        if fullname == 'classes.typeclass._TypeClass.instance':
             return _AdjustInstanceSignature().instance
         return None
 

classes/typeclass.py

@@ -4,13 +4,13 @@
 
 from typing_extensions import Literal
 
-_TypeClassType = TypeVar('_TypeClassType', contravariant=True)
+_TypeClassType = TypeVar('_TypeClassType')
 _ReturnType = TypeVar('_ReturnType')
 _CallbackType = TypeVar('_CallbackType')
 _InstanceType = TypeVar('_InstanceType')
 
 
-class TypeClass(Generic[_TypeClassType, _ReturnType, _CallbackType]):
+class _TypeClass(Generic[_TypeClassType, _ReturnType, _CallbackType]):
     """
     That's how we represent typeclasses.
 
@@ -20,7 +20,7 @@ class TypeClass(Generic[_TypeClassType, _ReturnType, _CallbackType]):
     .. code:: python
 
         >>> from typing import Callable
-        >>> from classes import TypeClass, typeclass
+        >>> from classes import typeclass
         >>> @typeclass
         ... def used(instance, other: int) -> int:
         ...     '''Example typeclass to be used later.'''
@@ -30,7 +30,7 @@ class TypeClass(Generic[_TypeClassType, _ReturnType, _CallbackType]):
         ...     return instance + other
         ...
         >>> def accepts_typeclass(
-        ...     callback: TypeClass[int, int, Callable[[int, int], int]],
+        ...     callback: Callable[[int, int], int],
         ... ) -> int:
         ...     return callback(1, 3)
         ...
@@ -92,6 +92,13 @@ def __call__(
         We don't guarantee the order of types inside groups.
         Use correct types, do not rely on our order.
 
+        Callbacks
+        ~~~~~~~~~
+
+        Since, we define ``__call__`` method for this class,
+        it can be used and typechecked everywhere,
+        where a regular ``Callable`` is expected.
+
         """
         instance_type = type(instance)
         implementation = self._instances.get(instance_type, None)
@@ -109,7 +116,7 @@ def __call__(
         )
 
     @overload
-    def instance(  # noqa: D102
+    def instance(
         self,
         type_argument: Type[_InstanceType],
         *,
@@ -121,7 +128,7 @@ def instance(  # noqa: D102
         ...
 
     @overload
-    def instance(  # noqa: D102
+    def instance(
         self,
         type_argument,
         *,
@@ -159,7 +166,7 @@ def typeclass(
     signature: _CallbackType,
     # By default `_TypeClassType` and `_ReturnType` are `nothing`,
     # but we enhance them via mypy plugin later:
-) -> TypeClass[_TypeClassType, _ReturnType, _CallbackType]:
+) -> _TypeClass[_TypeClassType, _ReturnType, _CallbackType]:
     """
     Function to define typeclasses.
 
@@ -318,4 +325,4 @@ def typeclass(
     Remember, that generic protocols have the same limitation as generic types.
 
     """
-    return TypeClass(signature)
+    return _TypeClass(signature)

tests/test_typeclass/test_callback.py

@@ -2,7 +2,7 @@
 
 from typing import Callable
 
-from classes import TypeClass, typeclass
+from classes import typeclass
 
 
 @typeclass
@@ -17,7 +17,7 @@ def _example_str(instance: str) -> int:
 
 def _callback(
     instance: str,
-    callback: TypeClass[str, int, Callable[[str], int]],
+    callback: Callable[[str], int],
 ) -> int:
     return callback(instance)
 

typesafety/test_typeclass/test_callback.yml

@@ -0,0 +1,46 @@
+- case: typeclass_callback_correct
+  disable_cache: true
+  main: |
+    from typing import Callable
+    from classes import typeclass
+
+    @typeclass
+    def example(instance, attr: bool) -> bool:
+        ...
+
+    @example.instance(int)
+    @example.instance(float)
+    def _example_int_float(intance, attr: bool) -> bool:
+        ...
+
+
+    def accepts_typeclass(callback: Callable[[int, bool], bool]) -> bool:
+        return callback(1, True)
+
+    reveal_type(accepts_typeclass(example))  # N: Revealed type is 'builtins.bool'
+
+
+- case: typeclass_callback_wrong
+  disable_cache: true
+  main: |
+    from typing import Callable
+    from classes import typeclass
+
+    @typeclass
+    def example(instance, attr: bool) -> bool:
+        ...
+
+    @example.instance(int)
+    @example.instance(float)
+    def _example_int_float(intance, attr: bool) -> bool:
+        ...
+
+
+    def accepts_typeclass(callback: Callable[[str, bool], bool]) -> bool:
+        return callback('a', True)
+
+    reveal_type(accepts_typeclass(example))
+  out: |
+    main:17: error: Argument 1 to "accepts_typeclass" has incompatible type "_TypeClass[Union[int, float], bool, Callable[[int, bool], bool]]"; expected "Callable[[str, bool], bool]"
+    main:17: note: "_TypeClass[Union[int, float], bool, Callable[[int, bool], bool]].__call__" has type "Callable[[Arg(Union[int, float], 'instance'), VarArg(Any), KwArg(Any)], bool]"
+    main:17: note: Revealed type is 'builtins.bool'

typesafety/test_typeclass/test_typeclass.yml

@@ -7,7 +7,7 @@
     def example(instance, arg: str, other: int, *, attr: bool) -> bool:
         ...
 
-    reveal_type(example)  # N: Revealed type is 'classes.typeclass.TypeClass[Any, builtins.bool, def (instance: Any, arg: builtins.str, other: builtins.int, *, attr: builtins.bool) -> builtins.bool]'
+    reveal_type(example)  # N: Revealed type is 'classes.typeclass._TypeClass[Any, builtins.bool, def (instance: Any, arg: builtins.str, other: builtins.int, *, attr: builtins.bool) -> builtins.bool]'
 
 
 - case: typeclass_instance
@@ -23,7 +23,7 @@
     def _example_str(instance: str, arg: str) -> bool:
         ...
 
-    reveal_type(example)  # N: Revealed type is 'classes.typeclass.TypeClass[builtins.str*, builtins.bool, def (builtins.str*, arg: builtins.str) -> builtins.bool]'
+    reveal_type(example)  # N: Revealed type is 'classes.typeclass._TypeClass[builtins.str*, builtins.bool, def (builtins.str*, arg: builtins.str) -> builtins.bool]'
 
 
 - case: typeclass_instance_union
@@ -44,7 +44,7 @@
     def _example_str(instance: str, arg: str) -> bool:
         ...
 
-    reveal_type(example)  # N: Revealed type is 'classes.typeclass.TypeClass[Union[builtins.str*, builtins.int*, builtins.float*], builtins.bool, def (builtins.str*, arg: builtins.str) -> builtins.bool]'
+    reveal_type(example)  # N: Revealed type is 'classes.typeclass._TypeClass[Union[builtins.str*, builtins.int*, builtins.float*], builtins.bool, def (builtins.str*, arg: builtins.str) -> builtins.bool]'
 
 
 - case: typeclass_incorrect_instance_callback1
@@ -63,7 +63,7 @@
     reveal_type(example)
   out: |
     main:7: error: Argument 1 has incompatible type "Callable[[str, str], bool]"; expected "Callable[[int, str], bool]"
-    main:11: note: Revealed type is 'classes.typeclass.TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'
+    main:11: note: Revealed type is 'classes.typeclass._TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'
 
 
 - case: typeclass_incorrect_instance_callback2
@@ -82,7 +82,7 @@
     reveal_type(example)
   out: |
     main:7: error: Argument 1 has incompatible type "Callable[[int], bool]"; expected "Callable[[int, str], bool]"
-    main:11: note: Revealed type is 'classes.typeclass.TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'
+    main:11: note: Revealed type is 'classes.typeclass._TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'
 
 
 - case: typeclass_incorrect_instance_callback3
@@ -101,4 +101,4 @@
     reveal_type(example)
   out: |
     main:7: error: Argument 1 has incompatible type "Callable[[Any, int], bool]"; expected "Callable[[int, str], bool]"
-    main:11: note: Revealed type is 'classes.typeclass.TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'
+    main:11: note: Revealed type is 'classes.typeclass._TypeClass[builtins.int*, builtins.bool, def (builtins.int*, arg: builtins.str) -> builtins.bool]'