from returns.interfaces import mappable
from returns.primitives.container import BaseContainer
from returns.primitives.hkt import SupportsKind1
pytestmark = pytest.mark.xfail
_ValueType = TypeVar('_ValueType')
_NewValueType = TypeVar('_NewValueType')
class _Wrapper(
BaseContainer,
SupportsKind1['_Wrapper', _ValueType],
mappable.Mappable1[_ValueType],
):
_inner_value: _ValueType
def __init__(self, inner_value: _ValueType) -> None:
super().__init__(inner_value)
def map( # noqa: WPS125
self,
function: Callable[[_ValueType], _NewValueType],
) -> '_Wrapper[_NewValueType]':
return _Wrapper(
'wrong-{0}'.format(function(self._inner_value)), # type: ignore
)
check_all_laws(_Wrapper, use_init=True)
_ValueType = TypeVar('_ValueType')
_NewValueType = TypeVar('_NewValueType')
class _Wrapper(
BaseContainer,
SupportsKind1['_Wrapper', _ValueType],
applicative.Applicative1[_ValueType],
):
_inner_value: _ValueType
def __init__(self, inner_value: _ValueType) -> None:
super().__init__(inner_value)
def apply(
self,
container: Kind1['_Wrapper', Callable[[_ValueType], _NewValueType]],
) -> '_Wrapper[_NewValueType]':
function = container._inner_value # noqa: WPS437
return _Wrapper(function(self._inner_value))
@classmethod
def from_value(
cls,
inner_value: _NewValueType,
) -> '_Wrapper[_NewValueType]':
return _Wrapper(inner_value)
check_all_laws(_Wrapper)
from returns.context import (
Reader,
ReaderFutureResult,
ReaderIOResult,
ReaderResult,
)
from returns.contrib.hypothesis.laws import check_all_laws
from returns.future import Future, FutureResult
from returns.io import IO, IOResult
from returns.maybe import Maybe
from returns.result import Result
pytestmark = pytest.mark.skipif(
sys.version_info < (3, 7),
reason='Python 3.6 does not support many hypothesis features',
)
check_all_laws(Maybe)
check_all_laws(Result)
check_all_laws(IO)
check_all_laws(IOResult)
check_all_laws(Future)
check_all_laws(FutureResult)
check_all_laws(Reader)
check_all_laws(ReaderResult)
check_all_laws(ReaderIOResult)
check_all_laws(ReaderFutureResult)
@classmethod
def from_paired(
cls,
first: _NewFirstType,
second: _NewSecondType,
) -> 'Pair[_NewFirstType, _NewSecondType]':
"""
Creates a new pair from two values.
>>> assert Pair.from_paired(1, 2) == Pair((1, 2))
"""
return Pair((first, second))
@classmethod
def from_unpaired(
cls,
inner_value: _NewFirstType,
) -> 'Pair[_NewFirstType, _NewFirstType]':
"""
Creates a new pair from a single value.
>>> assert Pair.from_unpaired(1) == Pair((1, 1))
"""
return Pair((inner_value, inner_value))
# Running hypothesis auto-generated tests:
check_all_laws(Pair, use_init=True)
