diff --git a/CHANGELOG.md b/CHANGELOG.md index 44a252302..abea09e50 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,12 @@ incremental in minor, bugfixes only are patches. See [0Ver](https://0ver.org/). +## 1.0.0 WIP + +### Misc + +- *Breaking*: Remove `success_type` and `failure_type` fields from `IOResult`, `Maybe` and `Result` types + ## 0.22.0 ### Features diff --git a/returns/_internal/futures/_future_result.py b/returns/_internal/futures/_future_result.py index 626439761..36c81bb0d 100644 --- a/returns/_internal/futures/_future_result.py +++ b/returns/_internal/futures/_future_result.py @@ -47,7 +47,7 @@ async def async_bind( ) -> Result[_NewValueType, _ErrorType]: """Async binds a container over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return (await dekind(function(container.unwrap())))._inner_value return container # type: ignore[return-value] @@ -58,7 +58,7 @@ async def async_bind_awaitable( ) -> Result[_NewValueType, _ErrorType]: """Async binds a coroutine over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return Result.from_value(await function(container.unwrap())) return container # type: ignore[return-value] @@ -72,7 +72,7 @@ async def async_bind_async( ) -> Result[_NewValueType, _ErrorType]: """Async binds a coroutine with container over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return await dekind(await function(container.unwrap()))._inner_value return container # type: ignore[return-value] @@ -91,7 +91,7 @@ async def async_bind_ioresult( ) -> Result[_NewValueType, _ErrorType]: """Async binds a container returning ``IOResult`` over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return function(container.unwrap())._inner_value return container # type: ignore[return-value] @@ -102,7 +102,7 @@ async def async_bind_io( ) -> Result[_NewValueType, _ErrorType]: """Async binds a container returning ``IO`` over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return Success(function(container.unwrap())._inner_value) return container # type: ignore[return-value] @@ -113,7 +113,7 @@ async def async_bind_future( ) -> Result[_NewValueType, _ErrorType]: """Async binds a container returning ``IO`` over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return await async_from_success(function(container.unwrap())) return container # type: ignore[return-value] @@ -124,7 +124,7 @@ async def async_bind_async_future( ) -> Result[_NewValueType, _ErrorType]: """Async binds a container returning ``IO`` over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return await async_from_success(await function(container.unwrap())) return container # type: ignore[return-value] @@ -135,7 +135,7 @@ async def async_alt( ) -> Result[_ValueType, _NewErrorType]: """Async alts a function over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return container return Failure(function(container.failure())) @@ -149,7 +149,7 @@ async def async_lash( ) -> Result[_ValueType, _NewErrorType]: """Async lashes a function returning a container over a value.""" container = await inner_value - if isinstance(container, Result.success_type): + if isinstance(container, Success): return container return (await dekind(function(container.failure())))._inner_value diff --git a/returns/_internal/futures/_reader_future_result.py b/returns/_internal/futures/_reader_future_result.py index 391491f8c..b9468d2be 100644 --- a/returns/_internal/futures/_reader_future_result.py +++ b/returns/_internal/futures/_reader_future_result.py @@ -1,7 +1,7 @@ from typing import TYPE_CHECKING, Awaitable, Callable, TypeVar from returns.primitives.hkt import Kind3, dekind -from returns.result import Result +from returns.result import Result, Success if TYPE_CHECKING: from returns.context import RequiresContextFutureResult # noqa: F401 @@ -29,7 +29,7 @@ async def async_bind_async( ) -> Result[_NewValueType, _ErrorType]: """Async binds a coroutine with container over a value.""" inner_value = await container(deps)._inner_value - if isinstance(inner_value, Result.success_type): + if isinstance(inner_value, Success): return await dekind( await function(inner_value.unwrap()), )(deps)._inner_value diff --git a/returns/context/requires_context_ioresult.py b/returns/context/requires_context_ioresult.py index 50e3ddb63..c6fe4785f 100644 --- a/returns/context/requires_context_ioresult.py +++ b/returns/context/requires_context_ioresult.py @@ -300,7 +300,7 @@ def bind_result( .. code:: python >>> from returns.context import RequiresContextIOResult - >>> from returns.result import Success, Failure, Result + >>> from returns.result import Failure, Result, Success >>> from returns.io import IOSuccess, IOFailure >>> def function(num: int) -> Result[int, str]: diff --git a/returns/context/requires_context_result.py b/returns/context/requires_context_result.py index 89962b03f..867b540ce 100644 --- a/returns/context/requires_context_result.py +++ b/returns/context/requires_context_result.py @@ -202,7 +202,7 @@ def apply( .. code:: python >>> from returns.context import RequiresContextResult - >>> from returns.result import Success, Failure, Result + >>> from returns.result import Failure, Success >>> def transform(arg: str) -> str: ... return arg + 'b' @@ -217,7 +217,7 @@ def apply( >>> assert isinstance(RequiresContextResult.from_value('a').apply( ... RequiresContextResult.from_failure(transform), - ... )(...), Result.failure_type) is True + ... )(...), Failure) is True """ return RequiresContextResult( diff --git a/returns/functions.py b/returns/functions.py index d55a18a80..3324b3382 100644 --- a/returns/functions.py +++ b/returns/functions.py @@ -141,7 +141,7 @@ def not_(function: Callable[_FuncParams, bool]) -> Callable[_FuncParams, bool]: >>> from returns.result import Result, Success, Failure >>> def is_successful(result_container: Result[float, int]) -> bool: - ... return isinstance(result_container, Result.success_type) + ... return isinstance(result_container, Success) >>> assert not_(is_successful)(Success(1.0)) is False >>> assert not_(is_successful)(Failure(1)) is True diff --git a/returns/future.py b/returns/future.py index c0b6abdda..093ed5f22 100644 --- a/returns/future.py +++ b/returns/future.py @@ -1478,7 +1478,7 @@ def future_safe( >>> import anyio >>> from returns.future import future_safe - >>> from returns.io import IOSuccess, IOResult + >>> from returns.io import IOFailure, IOSuccess >>> @future_safe ... async def might_raise(arg: int) -> float: @@ -1488,7 +1488,7 @@ def future_safe( >>> assert anyio.run(might_raise(2).awaitable) == IOSuccess(0.5) >>> assert isinstance( ... anyio.run(might_raise(0).awaitable), - ... IOResult.failure_type, + ... IOFailure, ... ) Similar to :func:`returns.io.impure_safe` and :func:`returns.result.safe` diff --git a/returns/io.py b/returns/io.py index a98ed3835..57891a7c1 100644 --- a/returns/io.py +++ b/returns/io.py @@ -5,12 +5,10 @@ TYPE_CHECKING, Any, Callable, - ClassVar, Generator, Iterator, List, Optional, - Type, TypeVar, Union, final, @@ -342,12 +340,6 @@ class IOResult( # type: ignore[type-var] _inner_value: Result[_ValueType, _ErrorType] __match_args__ = ('_inner_value',) - # These two are required for projects like `classes`: - #: Success type that is used to represent the successful computation. - success_type: ClassVar[Type['IOSuccess']] - #: Failure type that is used to represent the failed computation. - failure_type: ClassVar[Type['IOFailure']] - #: Typesafe equality comparison with other `IOResult` objects. equals = container_equality @@ -441,9 +433,9 @@ def apply( >>> assert IOFailure('a').apply(IOFailure('b')) == IOFailure('a') """ - if isinstance(self, self.failure_type): + if isinstance(self, IOFailure): return self - if isinstance(container, self.success_type): + if isinstance(container, IOSuccess): return self.from_result( self._inner_value.map( container.unwrap()._inner_value, # noqa: WPS437 @@ -757,7 +749,7 @@ def from_result( >>> assert IOResult.from_result(Failure(2)) == IOFailure(2) """ - if isinstance(inner_value, inner_value.success_type): + if isinstance(inner_value, Success): return IOSuccess(inner_value._inner_value) # noqa: WPS437 return IOFailure(inner_value._inner_value) # type: ignore[arg-type] # noqa: WPS437, E501 @@ -884,13 +876,9 @@ def lash(self, function): """Does nothing for ``IOSuccess``.""" return self - -IOResult.success_type = IOSuccess -IOResult.failure_type = IOFailure - - # Aliases: + #: Alias for a popular case when ``IOResult`` has ``Exception`` as error type. IOResultE = IOResult[_ValueType, Exception] diff --git a/returns/maybe.py b/returns/maybe.py index a686dc5a0..6d9657983 100644 --- a/returns/maybe.py +++ b/returns/maybe.py @@ -9,7 +9,6 @@ Iterator, NoReturn, Optional, - Type, TypeVar, Union, final, @@ -55,13 +54,6 @@ class Maybe( # type: ignore[type-var] #: Alias for `Nothing` empty: ClassVar['Maybe[Any]'] - # These two are required for projects like `classes`: - - #: Success type that is used to represent the successful computation. - success_type: ClassVar[Type['Some']] - #: Failure type that is used to represent the failed computation. - failure_type: ClassVar[Type['_Nothing']] - #: Typesafe equality comparison with other `Result` objects. equals = container_equality @@ -431,7 +423,7 @@ def map(self, function): def apply(self, container): """Calls a wrapped function in a container on this container.""" - if isinstance(container, self.success_type): + if isinstance(container, Some): return self.map(container.unwrap()) # type: ignore return container @@ -452,9 +444,6 @@ def failure(self): raise UnwrapFailedError(self) -Maybe.success_type = Some -Maybe.failure_type = _Nothing - #: Public unit value of protected :class:`~_Nothing` type. Nothing: Maybe[NoReturn] = _Nothing() Maybe.empty = Nothing diff --git a/returns/result.py b/returns/result.py index 2cea4695e..b8e3afbea 100644 --- a/returns/result.py +++ b/returns/result.py @@ -5,7 +5,6 @@ TYPE_CHECKING, Any, Callable, - ClassVar, Generator, Iterator, List, @@ -60,12 +59,6 @@ class Result( # type: ignore[type-var] _inner_value: Union[_ValueType, _ErrorType] _trace: Optional[List[FrameInfo]] - # These two are required for projects like `classes`: - #: Success type that is used to represent the successful computation. - success_type: ClassVar[Type['Success']] - #: Failure type that is used to represent the failed computation. - failure_type: ClassVar[Type['Failure']] - #: Typesafe equality comparison with other `Result` objects. equals = container_equality @@ -453,7 +446,7 @@ def lash(self, function): def apply(self, container): """Calls a wrapped function in a container on this container.""" - if isinstance(container, self.success_type): + if isinstance(container, Success): return self.map(container.unwrap()) return container @@ -474,9 +467,6 @@ def failure(self) -> NoReturn: raise UnwrapFailedError(self) -Result.success_type = Success -Result.failure_type = Failure - # Aliases: #: Alias for a popular case when ``Result`` has ``Exception`` as error type. @@ -524,27 +514,27 @@ def safe( # type: ignore # noqa: WPS234, C901 .. code:: python - >>> from returns.result import Result, Success, safe + >>> from returns.result import Failure, Success, safe >>> @safe ... def might_raise(arg: int) -> float: ... return 1 / arg >>> assert might_raise(1) == Success(1.0) - >>> assert isinstance(might_raise(0), Result.failure_type) + >>> assert isinstance(might_raise(0), Failure) You can also use it with explicit exception types as the first argument: .. code:: python - >>> from returns.result import Result, Success, safe + >>> from returns.result import Failure, Success, safe >>> @safe(exceptions=(ZeroDivisionError,)) ... def might_raise(arg: int) -> float: ... return 1 / arg >>> assert might_raise(1) == Success(1.0) - >>> assert isinstance(might_raise(0), Result.failure_type) + >>> assert isinstance(might_raise(0), Failure) In this case, only exceptions that are explicitly listed are going to be caught. diff --git a/tests/test_future/test_future_result/test_future_result_decorator.py b/tests/test_future/test_future_result/test_future_result_decorator.py index f953ac4c2..be2486db1 100644 --- a/tests/test_future/test_future_result/test_future_result_decorator.py +++ b/tests/test_future/test_future_result/test_future_result_decorator.py @@ -1,7 +1,7 @@ import pytest from returns.future import FutureResult, future_safe -from returns.io import IOResult, IOSuccess +from returns.io import IOFailure, IOSuccess @future_safe @@ -24,4 +24,4 @@ async def test_future_safe_decorator_failure(): future_instance = _coro(0) assert isinstance(future_instance, FutureResult) - assert isinstance(await future_instance, IOResult.failure_type) + assert isinstance(await future_instance, IOFailure) diff --git a/tests/test_io/test_ioresult_container/test_ioresult_base.py b/tests/test_io/test_ioresult_container/test_ioresult_base.py deleted file mode 100644 index 3a38a6982..000000000 --- a/tests/test_io/test_ioresult_container/test_ioresult_base.py +++ /dev/null @@ -1,7 +0,0 @@ -from returns.io import IOResult - - -def test_ioresult_types(): - """Ensures that Result has two types inside a class.""" - assert isinstance(IOResult.success_type, type) - assert isinstance(IOResult.failure_type, type) diff --git a/tests/test_maybe/test_maybe_base.py b/tests/test_maybe/test_maybe_base.py deleted file mode 100644 index e925a8c32..000000000 --- a/tests/test_maybe/test_maybe_base.py +++ /dev/null @@ -1,7 +0,0 @@ -from returns.maybe import Maybe - - -def test_maybe_types(): - """Checks that we have correct types inside Maybe.""" - assert isinstance(Maybe.success_type, type) - assert isinstance(Maybe.failure_type, type) diff --git a/tests/test_result/test_result_base.py b/tests/test_result/test_result_base.py deleted file mode 100644 index d39257507..000000000 --- a/tests/test_result/test_result_base.py +++ /dev/null @@ -1,7 +0,0 @@ -from returns.result import Result - - -def test_result_types(): - """Ensures that Result has two types inside a class.""" - assert isinstance(Result.success_type, type) - assert isinstance(Result.failure_type, type) diff --git a/typesafety/test_io/test_ioresult_container/test_ioresult_helpers.yml b/typesafety/test_io/test_ioresult_container/test_ioresult_helpers.yml index cef36affd..f22f0f78b 100644 --- a/typesafety/test_io/test_ioresult_container/test_ioresult_helpers.yml +++ b/typesafety/test_io/test_ioresult_container/test_ioresult_helpers.yml @@ -27,19 +27,3 @@ container: IO[str] reveal_type(IOResult.from_failed_io(container)) # N: Revealed type is "returns.io.IOResult[Any, builtins.str]" - - -- case: ioresult_success_type - disable_cache: false - main: | - from returns.io import IOResult - - reveal_type(IOResult.success_type) # N: Revealed type is "Type[returns.io.IOSuccess[Any]]" - - -- case: ioresult_failure_type - disable_cache: false - main: | - from returns.io import IOResult - - reveal_type(IOResult.failure_type) # N: Revealed type is "Type[returns.io.IOFailure[Any]]" diff --git a/typesafety/test_maybe/test_maybe_type_cast.yml b/typesafety/test_maybe/test_maybe_type_cast.yml index f798eac89..7c227fb40 100644 --- a/typesafety/test_maybe/test_maybe_type_cast.yml +++ b/typesafety/test_maybe/test_maybe_type_cast.yml @@ -31,20 +31,3 @@ from returns.maybe import Nothing reveal_type(Nothing) # N: Revealed type is "returns.maybe.Maybe[]" - - -- case: maybe_result_success_type - disable_cache: false - main: | - from returns.maybe import Maybe - - reveal_type(Maybe.success_type) # N: Revealed type is "Type[returns.maybe.Some[Any]]" - - -- case: maybe_result_failure_type - disable_cache: false - main: | - from returns.maybe import Maybe - - reveal_type(Maybe.failure_type) # N: Revealed type is "Type[returns.maybe._Nothing]" - diff --git a/typesafety/test_result/test_result_type_cast.yml b/typesafety/test_result/test_result_type_cast.yml index 766dc2ea4..f2fce9df7 100644 --- a/typesafety/test_result/test_result_type_cast.yml +++ b/typesafety/test_result/test_result_type_cast.yml @@ -125,22 +125,6 @@ reveal_type(factory(1)) # N: Revealed type is "returns.result.Result[builtins.int, builtins.str]" -- case: result_success_type - disable_cache: false - main: | - from returns.result import Result - - reveal_type(Result.success_type) # N: Revealed type is "Type[returns.result.Success[Any]]" - - -- case: result_failure_type - disable_cache: false - main: | - from returns.result import Result - - reveal_type(Result.failure_type) # N: Revealed type is "Type[returns.result.Failure[Any]]" - - - case: resulte_typecast1 disable_cache: false main: |