Refactor decorators (#1891)

Author: sobolevn

CHANGELOG.md

@@ -8,17 +8,22 @@ See [0Ver](https://0ver.org/).
 
 ## 0.24.0 WIP
 
+### Deprecated
+
+- `returns.result.ResultE` alias
+- `returns.io.IOResultE` alias
+- `returns.future.FutureResultE` alias
+
 ### Features
 
 - Add picky exceptions to `future_safe` decorator like `safe` has.
 - Improve inference of `ResultLike` objects when exception catching
   decorator is applied with explicit exception types
 - Add picky exceptions to `impure_safe` decorator like `safe` has. Issue #1543
 
+### Misc
 
-## Deprecated
-
-- FutureResultE from future
+- Now requires `mypy>=1.11`
 
 
 ## 0.23.0

returns/future.py

@@ -15,7 +15,7 @@
     overload,
 )
 
-from typing_extensions import ParamSpec
+from typing_extensions import ParamSpec, TypeAlias
 
 from returns._internal.futures import _future, _future_result
 from returns.interfaces.specific.future import FutureBased1
@@ -1454,8 +1454,8 @@ def FutureFailure(  # noqa: N802
     return FutureResult.from_failure(inner_value)
 
 
-# Deprecated
-FutureResultE = FutureResult[_ValueType, Exception]
+#: Deprecated alias for ``FutureResult[_ValueType, Exception]``.
+FutureResultE: TypeAlias = FutureResult[_ValueType, Exception]
 
 
 _ExceptionType = TypeVar('_ExceptionType', bound=Exception)

returns/io.py

@@ -17,7 +17,7 @@
     overload,
 )
 
-from typing_extensions import ParamSpec
+from typing_extensions import ParamSpec, TypeAlias
 
 from returns.interfaces.specific import io, ioresult
 from returns.primitives.container import BaseContainer, container_equality
@@ -882,8 +882,8 @@ def lash(self, function):
 # Aliases:
 
 
-#: Alias for a popular case when ``IOResult`` has ``Exception`` as error type.
-IOResultE = IOResult[_ValueType, Exception]
+#: Deprecated alias for ``IOResult[_ValueType, Exception]``.
+IOResultE: TypeAlias = IOResult[_ValueType, Exception]
 
 
 # impure_safe decorator:
@@ -894,7 +894,8 @@ def lash(self, function):
 @overload
 def impure_safe(
     function: Callable[_FuncParams, _NewValueType],
-) -> Callable[_FuncParams, IOResultE[_NewValueType]]:
+    /,
+) -> Callable[_FuncParams, IOResult[_NewValueType, Exception]]:
     """Decorator to convert exception-throwing for any kind of Exception."""
 
 
@@ -908,11 +909,13 @@ def impure_safe(
     """Decorator to convert exception-throwing just for a set of Exceptions."""
 
 
-def impure_safe(  # type: ignore # noqa: WPS234, C901
-    function: Optional[Callable[_FuncParams, _NewValueType]] = None,
-    exceptions: Optional[Tuple[Type[_ExceptionType], ...]] = None,
+def impure_safe(  # noqa: WPS234, C901
+    exceptions: Union[
+        Callable[_FuncParams, _NewValueType],
+        Tuple[Type[_ExceptionType], ...],
+    ],
 ) -> Union[
-    Callable[_FuncParams, IOResultE[_NewValueType]],
+    Callable[_FuncParams, IOResult[_NewValueType, Exception]],
     Callable[
         [Callable[_FuncParams, _NewValueType]],
         Callable[_FuncParams, IOResult[_NewValueType, _ExceptionType]],
@@ -961,19 +964,22 @@ def impure_safe(  # type: ignore # noqa: WPS234, C901
     """
     def factory(
         inner_function: Callable[_FuncParams, _NewValueType],
-        inner_exceptions: Tuple[Type[Exception], ...],
-    ) -> Callable[_FuncParams, IOResultE[_NewValueType]]:
+        inner_exceptions: Tuple[Type[_ExceptionType], ...],
+    ) -> Callable[_FuncParams, IOResult[_NewValueType, _ExceptionType]]:
         @wraps(inner_function)
-        def decorator(*args: _FuncParams.args, **kwargs: _FuncParams.kwargs):
+        def decorator(
+            *args: _FuncParams.args,
+            **kwargs: _FuncParams.kwargs,
+        ) -> IOResult[_NewValueType, _ExceptionType]:
             try:
                 return IOSuccess(inner_function(*args, **kwargs))
             except inner_exceptions as exc:
                 return IOFailure(exc)
         return decorator
 
-    if callable(function):
-        return factory(function, exceptions or (Exception,))
-    if isinstance(function, tuple):
-        exceptions = function  # type: ignore
-        function = None
-    return lambda function: factory(function, exceptions)  # type: ignore
+    if isinstance(exceptions, tuple):
+        return lambda function: factory(function, exceptions)
+    return factory(
+        exceptions,
+        (Exception,),  # type: ignore[arg-type]
+    )

returns/result.py

@@ -17,7 +17,7 @@
     overload,
 )
 
-from typing_extensions import Never, ParamSpec
+from typing_extensions import Never, ParamSpec, TypeAlias
 
 from returns.interfaces.specific import result
 from returns.primitives.container import BaseContainer, container_equality
@@ -468,8 +468,8 @@ def failure(self) -> Never:
 
 # Aliases:
 
-#: Alias for a popular case when ``Result`` has ``Exception`` as error type.
-ResultE = Result[_ValueType, Exception]
+#: Deprecated alias for ``Result[_ValueType, Exception]``.
+ResultE: TypeAlias = Result[_ValueType, Exception]
 
 
 # Decorators:
@@ -480,7 +480,8 @@ def failure(self) -> Never:
 @overload
 def safe(
     function: Callable[_FuncParams, _ValueType],
-) -> Callable[_FuncParams, ResultE[_ValueType]]:
+    /,
+) -> Callable[_FuncParams, Result[_ValueType, Exception]]:
     """Decorator to convert exception-throwing for any kind of Exception."""
 
 
@@ -494,11 +495,13 @@ def safe(
     """Decorator to convert exception-throwing just for a set of Exceptions."""
 
 
-def safe(  # type: ignore # noqa: WPS234, C901
-    function: Optional[Callable[_FuncParams, _ValueType]] = None,
-    exceptions: Optional[Tuple[Type[_ExceptionType], ...]] = None,
+def safe(  # noqa: WPS234, C901
+    exceptions: Union[
+        Callable[_FuncParams, _ValueType],
+        Tuple[Type[_ExceptionType], ...],
+    ],
 ) -> Union[
-    Callable[_FuncParams, ResultE[_ValueType]],
+    Callable[_FuncParams, Result[_ValueType, Exception]],
     Callable[
         [Callable[_FuncParams, _ValueType]],
         Callable[_FuncParams, Result[_ValueType, _ExceptionType]],
@@ -546,22 +549,25 @@ def safe(  # type: ignore # noqa: WPS234, C901
     """
     def factory(
         inner_function: Callable[_FuncParams, _ValueType],
-        inner_exceptions: Tuple[Type[Exception], ...],
-    ) -> Callable[_FuncParams, ResultE[_ValueType]]:
+        inner_exceptions: Tuple[Type[_ExceptionType], ...],
+    ) -> Callable[_FuncParams, Result[_ValueType, _ExceptionType]]:
         @wraps(inner_function)
-        def decorator(*args: _FuncParams.args, **kwargs: _FuncParams.kwargs):
+        def decorator(
+            *args: _FuncParams.args,
+            **kwargs: _FuncParams.kwargs,
+        ) -> Result[_ValueType, _ExceptionType]:
             try:
                 return Success(inner_function(*args, **kwargs))
             except inner_exceptions as exc:
                 return Failure(exc)
         return decorator
 
-    if callable(function):
-        return factory(function, (Exception,))
-    if isinstance(function, tuple):
-        exceptions = function  # type: ignore
-        function = None
-    return lambda function: factory(function, exceptions)  # type: ignore
+    if isinstance(exceptions, tuple):
+        return lambda function: factory(function, exceptions)
+    return factory(
+        exceptions,
+        (Exception,),  # type: ignore[arg-type]
+    )
 
 
 def attempt(