Methods

The following useful methods can be used to interact with interfaces.

cond

Note

cond is also the name of a function in the Pointfree module. Therefore we encourage to import the modules pointfree and methods directly instead of their functions.

Reduce the boilerplate when choosing paths with DiverseFailableN. Think of this method as a functional if alternative for successful or failed types.

So, this code:

>>> from returns.result import Failure, Result, Success

>>> def is_numeric(string: str) -> Result[str, str]:
...     if string.isnumeric():
...          return Success('It is a number')
...     return Failure('It is not a number')

Can be replaced with this:

>>> from returns import methods
>>> from returns.result import Failure, Result, Success

>>> def is_numeric(string: str) -> Result[str, str]:
...     return methods.cond(
...         Result,
...         string.isnumeric(),
...         'It is a number',
...         'It is not a number',
...    )

>>> assert is_numeric('42') == Success('It is a number')
>>> assert is_numeric('text') == Failure('It is not a number')

Why is it helpful? Because cond can be easily added into a Pipelines of functions.

unwrap_or_failure

Unwraps either a successful or failed value.

>>> from returns.io import IO, IOSuccess, IOFailure
>>> from returns import methods

>>> assert methods.unwrap_or_failure(IOSuccess(1)) == IO(1)
>>> assert methods.unwrap_or_failure(IOFailure('a')) == IO('a')

Useful when you have a ResultLike value with correctly handled error value, for example with bimap(). Here’s a full example:

>>> from returns.result import Failure, Result, Success
>>> from returns import methods, pointfree

>>> instance: Result[int, str] = Success(1)
>>> error_handled = pointfree.bimap(lambda inr: inr + 1, lambda _: 0)(instance)
>>> assert isinstance(methods.unwrap_or_failure(error_handled), int)

partition

partition is used to convert list of Unwrappable instances like Result, IOResult, and Maybe to a tuple of two lists: successes and failures.

>>> from returns.result import Failure, Success
>>> from returns.methods import partition
>>> results = [Success(1), Failure(2), Success(3), Failure(4)]
>>> partition(results)
([1, 3], [2, 4])

API Reference

cond(container_type, is_success, success_value, error_value=None)

Kinded version of internal_cond(), use it to infer real return type.

Parameters:

• container_type (type[TypeVar(_SingleFailableKind, bound= SingleFailableN)] | type[TypeVar(_DiverseFailableKind, bound= DiverseFailableN)])

• is_success (bool)

• success_value (TypeVar(_ValueType))

• error_value (Optional[TypeVar(_ErrorType)])

unwrap_or_failure(container)

Unwraps either successful or failed value.

>>> from returns.io import IO, IOSuccess, IOFailure
>>> from returns.methods import unwrap_or_failure

>>> assert unwrap_or_failure(IOSuccess(1)) == IO(1)
>>> assert unwrap_or_failure(IOFailure('a')) == IO('a')

Parameters:

container (Unwrappable[TypeVar(_FirstType), TypeVar(_SecondType)])

Return type:

Union[TypeVar(_FirstType), TypeVar(_SecondType)]