Closes #98, closes #141 (#147)

* Closes #98, closes #141

* Fixes CI

* Fixes CI

* Fixes CI

* Fixes CI

* Fixes CI

Author: sobolevn

.github/workflows/test.yml

@@ -1,13 +1,13 @@
 name: test
 
-on: [push, pull_request]
+on: [push, pull_request, workflow_dispatch]
 
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8]
+        python-version: [3.6, 3.7, 3.8, 3.9]
 
 
     steps:
@@ -16,25 +16,28 @@ jobs:
       uses: actions/setup-python@v1
       with:
         python-version: ${{ matrix.python-version }}
-    
+
     - name: Install poetry
       run: |
+        pip install -U pip
+
         curl -sSL \
           "https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py" | python
+
+        echo "${HOME}/.poetry/bin" >> $GITHUB_PATH
+
     - name: Set up cache
       uses: actions/cache@v1
       with:
         path: .venv
         key: venv-${{ matrix.python-version }}-${{ hashFiles('poetry.lock') }}
     - name: Install dependencies
       run: |
-        source "$HOME/.poetry/env"
-
         poetry config virtualenvs.in-project true
         poetry install
+
     - name: Run tests
       run: |
-        source "$HOME/.poetry/env"
         poetry run flake8 .
         poetry run mypy classes ./tests/**/*.py
         poetry run pytest . docs/pages

CHANGELOG.md

@@ -3,6 +3,18 @@
 We follow Semantic Versions since the `0.1.0` release.
 
 
+## Version 0.2.0 WIP
+
+### Features
+
+- **Breaking**: renames mypy `typeclass_plugin` to `classes_plugin`
+- Adds `python3.9` support
+
+### Misc
+
+- Updates dependencies
+
+
 ## Version 0.1.0
 
 - Initial release

README.md

@@ -40,7 +40,7 @@ to fix [this existing issue](https://github.com/python/mypy/issues/3157):
 # In setup.cfg or mypy.ini:
 [mypy]
 plugins =
-  classes.contrib.mypy.typeclass_plugin
+  classes.contrib.mypy.classes_plugin
 ```
 
 **Without this step**, your project will report type-violations here and there.

classes/__init__.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """
 Here we define the public API of our module.
 

classes/contrib/mypy/typeclass_plugin.py renamed to classes/contrib/mypy/classes_plugin.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 """
 Custom mypy plugin to enable typeclass concept to work.
 
@@ -27,7 +25,7 @@
 
 def _adjust_arguments(ctx):
     typeclass_def = ctx.default_return_type.args[2]
-    if not isinstance(typeclass_def, CallableType):
+    if not isinstance(typeclass_def, CallableType):  # TODO: FunctionLike?
         return ctx.default_return_type
 
     args = [

classes/typeclass.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 from typing import Callable, Dict, Generic, NoReturn, Type, TypeVar, overload
 
 from typing_extensions import Literal
@@ -24,21 +22,21 @@ class _TypeClass(Generic[_TypeClassType, _ReturnType, _CallbackType]):
         >>> @typeclass
         ... def used(instance, other: int) -> int:
         ...     '''Example typeclass to be used later.'''
-        ...
+
         >>> @used.instance(int)
         ... def _used_int(instance: int, other: int) -> int:
         ...     return instance + other
-        ...
+
         >>> def accepts_typeclass(
         ...     callback: Callable[[int, int], int],
         ... ) -> int:
         ...     return callback(1, 3)
-        ...
-        >>> accepts_typeclass(used)
-        4
+
+        >>> assert accepts_typeclass(used) == 4
 
     Take a note, that we structural subtyping here.
-    And all typeclasses that match this signature will typecheck.
+    And all typeclasses that match ``Callable[[int, int], int]`` signature
+    will typecheck.
 
     """
 
@@ -123,8 +121,8 @@ def instance(
     ) -> Callable[
         [Callable[[_InstanceType], _ReturnType]],
         NoReturn,  # We need this type to disallow direct instance calls
-    ]:  # pragma: no cover
-        ...
+    ]:
+        """Case for regular typeclasses."""
 
     @overload
     def instance(
@@ -135,8 +133,8 @@ def instance(
     ) -> Callable[
         [Callable[[_InstanceType], _ReturnType]],
         NoReturn,  # We need this type to disallow direct instance calls
-    ]:  # pragma: no cover
-        ...
+    ]:
+        """Case for protocol based typeclasses."""
 
     def instance(
         self,
@@ -182,7 +180,7 @@ def typeclass(
         >>> @typeclass
         ... def example(instance) -> str:
         ...     '''Example typeclass.'''
-        ...
+
         >>> example(1)
         Traceback (most recent call last):
         ...
@@ -202,9 +200,8 @@ def typeclass(
         >>> @example.instance(int)
         ... def _example_int(instance: int) -> str:
         ...     return 'int case'
-        ...
-        >>> example(1)
-        'int case'
+
+        >>> assert example(1) == 'int case'
 
     Now we have a specific instance for ``int``
     which does something different from the default implementation.
@@ -227,9 +224,8 @@ def typeclass(
         >>> @example.instance(str)
         ... def _example_str(instance: str) -> str:
         ...     return instance
-        ...
-        >>> example('a')
-        'a'
+
+        >>> assert example('a') == 'a'
 
     Now it works with ``str`` as well. But differently.
     This allows developer to base the implementation on type information.
@@ -252,7 +248,6 @@ def typeclass(
         >>> class MyGeneric(Generic[T]):
         ...     def __init__(self, arg: T) -> None:
         ...          self.arg = arg
-        ...
 
     Now, let's define the typeclass instance for this type:
 
@@ -261,17 +256,15 @@ def typeclass(
         >>> @example.instance(MyGeneric)
         ... def _my_generic_example(instance: MyGeneric) -> str:
         ...     return 'generi' + str(instance.arg)
-        ...
-        >>> example(MyGeneric('c'))
-        'generic'
+
+        >>> assert example(MyGeneric('c')) == 'generic'
 
     This case will work for all type parameters of ``MyGeneric``,
     or in other words it can be assumed as ``MyGeneric[Any]``:
 
     .. code:: python
 
-        >>> example(MyGeneric(1))
-        'generi1'
+        >>> assert example(MyGeneric(1)) == 'generi1'
 
     In the future, when Python will have new type mechanisms,
     we would like to improve our support for specific generic instances
@@ -290,16 +283,14 @@ def typeclass(
         >>> @example.instance(Sequence, is_protocol=True)
         ... def _sequence_example(instance: Sequence) -> str:
         ...     return ','.join(str(item) for item in instance)
-        ...
-        >>> example([1, 2, 3])
-        '1,2,3'
+
+        >>> assert example([1, 2, 3]) == '1,2,3'
 
     But, ``str`` will still have higher priority over ``Sequence``:
 
     .. code:: python
 
-        >>> example('abc')
-        'abc'
+        >>> assert example('abc') == 'abc'
 
     We also support user-defined protocols:
 
@@ -308,21 +299,19 @@ def typeclass(
         >>> from typing_extensions import Protocol
         >>> class CustomProtocol(Protocol):
         ...     field: str
-        ...
+
         >>> @example.instance(CustomProtocol, is_protocol=True)
         ... def _custom_protocol_example(instance: CustomProtocol) -> str:
         ...     return instance.field
-        ...
 
     Now, let's build a class that match this protocol and test it:
 
     .. code:: python
 
         >>> class WithField(object):
         ...    field: str = 'with field'
-        ...
-        >>> example(WithField())
-        'with field'
+
+        >>> assert example(WithField()) == 'with field'
 
     Remember, that generic protocols have the same limitation as generic types.
 

docs/pages/concept.rst

@@ -67,7 +67,6 @@ The first on is "Typeclass definition", where we create a new typeclass:
   >>> @typeclass
   ... def json(instance) -> str:
   ...     """That's definition!"""
-  ...
 
 When typeclass is defined it only has a name and a signature
 that all instances will share.
@@ -78,12 +77,11 @@ Let's define some instances:
   >>> @json.instance(str)
   ... def _json_str(instance: str) -> str:
   ...     return '"{0}"'.format(instance)
-  ...
+
   >>> @json.instance(int)
   ... @json.instance(float)
   ... def _json_int_float(instance) -> str:
   ...     return str(instance)
-  ...
 
 That's how we define instances for our typeclass.
 These instances will be executed when the corresponding type will be supplied.
@@ -93,12 +91,9 @@ with different value of different types:
 
 .. code:: python
 
-  >>> json('text')
-  '"text"'
-  >>> json(1)
-  '1'
-  >>> json(1.5)
-  '1.5'
+  >>> assert json('text') == '"text"'
+  >>> assert json(1) == '1'
+  >>> assert json(1.5) == '1.5'
 
 That's it. There's nothing extra about typeclasses. They can be:
 
@@ -128,17 +123,16 @@ function signatures and return types in all cases:
   >>> @singledispatch
   ... def example(instance) -> str:
   ...     return 'default'
-  ...
+
   >>> @example.register(int)
   ... def _example_int(instance: int, other: int) -> int:
   ...     return instance + other
-  ...
+
   >>> @example.register(str)
   ... def _example_str(instance: str) -> bool:
   ...     return bool(instance)
-  ...
-  >>> bool(example(1, 0)) == example('a')
-  True
+
+  >>> assert bool(example(1, 0)) == example('a')
 
 As you can see: you are able to create
 instances with different return types and number of parameters.

docs/pages/typesafety.rst

@@ -18,14 +18,14 @@ First of all, we always check that the signature is the same for all cases.
 .. code:: python
 
   >>> from classes import typeclass
+
   >>> @typeclass
   ... def example(instance, arg: int, *, keyword: str) -> bool:
   ...     ...
-  ...
+
   >>> @example.instance(str)
   ... def _example_str(instance: str, arg: int, *, keyword: str) -> bool:
   ...     return instance * arg + keyword
-  ...
 
 Let's look at this example closely:
 
@@ -72,10 +72,11 @@ So, this would not work:
 
   >>> from typing import List
   >>> from classes import typeclass
+
   >>> @typeclass
   ... def generic_typeclass(instance) -> str:
   ...     """We use this example to demonstrate the typing limitation."""
-  ...
+
   >>> @generic_typeclass.instance(List[int])
   ... def _generic_typeclass_list_int(instance: List[int]):
   ...   ...
@@ -91,18 +92,17 @@ But, this will (note that we use ``list`` inside ``.instance()`` call):
 
   >>> from typing import List
   >>> from classes import typeclass
+
   >>> @typeclass
   ... def generic_typeclass(instance) -> str:
   ...     """We use this example to demonstrate the typing limitation."""
-  ...
+
   >>> @generic_typeclass.instance(list)
   ... def _generic_typeclass_list_int(instance: List):
   ...   return ''.join(str(list_item) for list_item in instance)
-  ...
-  >>> generic_typeclass([1, 2, 3])
-  '123'
-  >>> generic_typeclass(['a', 1, True])
-  'a1True'
+
+  >>> assert generic_typeclass([1, 2, 3]) == '123'
+  >>> assert generic_typeclass(['a', 1, True]) == 'a1True'
 
 Use primitive generics as they always have ``Any`` inside.
 Annotations should also be bound to any parameters.