class MaybeLikeN(
failable.SingleFailableN[_FirstType, _SecondType, _ThirdType],
Lawful['MaybeLikeN[_FirstType, _SecondType, _ThirdType]'],
):
"""
Type for values that do look like a ``Maybe``.
For example, ``RequiresContextMaybe`` should be created from this interface.
Cannot be unwrapped or compared.
"""
_laws: ClassVar[Sequence[Law]] = (
Law2(_LawSpec.map_short_circuit_law),
Law2(_LawSpec.bind_short_circuit_law),
Law2(_LawSpec.bind_optional_short_circuit_law),
Law3(_LawSpec.lash_short_circuit_law),
Law2(_LawSpec.unit_structure_law),
)
@abstractmethod
def bind_optional(
self: _MaybeLikeType,
function: Callable[[_FirstType], Optional[_UpdatedType]],
) -> KindN[_MaybeLikeType, _UpdatedType, _SecondType, _ThirdType]:
"""Binds a function that returns ``Optional`` values."""
@classmethod
@abstractmethod
def from_optional(
cls: Type[_MaybeLikeType], # noqa: N805
inner_value: Optional[_ValueType],
) -> KindN[_MaybeLikeType, _ValueType, _SecondType, _ThirdType]:
"""Unit method to create containers from ``Optional`` value."""
class ReaderResultBasedN(
ReaderResultLikeN[_FirstType, _SecondType, _ThirdType],
reader.CallableReader3[
_FirstType,
_SecondType,
_ThirdType,
# Calls:
'Result[_FirstType, _SecondType]',
_ThirdType,
],
Lawful['ReaderResultBasedN[_FirstType, _SecondType, _ThirdType]'],
):
"""
This interface is very specific to our ``ReaderResult`` type.
The only thing that differs from ``ReaderResultLikeN`` is that we know
the specific types for its ``__call__`` method.
In this case the return type of ``__call__`` is ``Result``.
"""
_laws: ClassVar[Sequence[Law]] = (
Law2(_LawSpec.purity_law),
Law2(_LawSpec.asking_law),
)
class ReaderBased2(
CallableReader2[_FirstType, _SecondType,
# Used for call typing:
_FirstType, _SecondType, ],
Lawful['ReaderBased2[_FirstType, _SecondType]'],
):
"""
This interface is very specific to our ``Reader`` type.
The only thing that differs from ``ReaderLike2`` is that we know
the specific types for its ``__call__`` method.
"""
_laws: ClassVar[Sequence[Law]] = (
Law2(_LawSpec.purity_law),
Law2(_LawSpec.asking_law),
)
class SingleFailableN(
FailableN[_FirstType, _SecondType, _ThirdType], ):
"""
Base type for types that have just only one failed value.
Like ``Maybe`` types where the only failed value is ``Nothing``.
"""
_laws: ClassVar[Sequence[Law]] = (
Law2(_SingleFailableLawSpec.map_short_circuit_law),
Law2(_SingleFailableLawSpec.bind_short_circuit_law),
Law2(_SingleFailableLawSpec.apply_short_circuit_law),
)
@property
@abstractmethod
def empty(
self: _SingleFailableType,
) -> 'SingleFailableN[_FirstType, _SecondType, _ThirdType]':
"""This property represents the failed value."""
class Equable(Lawful['Equable']):
"""
Interface for types that can be compared with real values.
Not all types can, because some don't have the value at a time:
- ``Future`` has to be awaited to get the value
- ``Reader`` has to be called to get the value
"""
_laws: ClassVar[Sequence[Law]] = (
Law1(_LawSpec.reflexive_law),
Law2(_LawSpec.symmetry_law),
Law3(_LawSpec.transitivity_law),
)
@abstractmethod
def equals(self: _EqualType, other: _EqualType) -> bool:
"""Type-safe equality check for values of the same type."""
class PairLikeN(
bindable.BindableN[_FirstType, _SecondType, _ThirdType],
swappable.SwappableN[_FirstType, _SecondType, _ThirdType],
lashable.LashableN[_FirstType, _SecondType, _ThirdType],
equable.Equable,
):
"""Special interface for types that look like a ``Pair``."""
_laws: ClassVar[Sequence[Law]] = (
Law2(_LawSpec.pair_equality_law),
Law3(_LawSpec.pair_left_identity_law),
)
@abstractmethod
def pair(
self: _PairLikeKind,
function: Callable[
[_FirstType, _SecondType],
KindN[_PairLikeKind, _NewFirstType, _NewSecondType, _ThirdType],
],
) -> KindN[_PairLikeKind, _NewFirstType, _NewSecondType, _ThirdType]:
"""Allows to work with both arguments at the same time."""
@classmethod
@abstractmethod
def from_paired(
cls: Type[_PairLikeKind],
first: _NewFirstType,
second: _NewSecondType,
) -> KindN[_PairLikeKind, _NewFirstType, _NewSecondType, _ThirdType]:
"""Allows to create a PairLikeN from just two values."""
@classmethod
@abstractmethod
def from_unpaired(
cls: Type[_PairLikeKind],
inner_value: _NewFirstType,
) -> KindN[_PairLikeKind, _NewFirstType, _NewFirstType, _ThirdType]:
"""Allows to create a PairLikeN from just a single object."""
