Module fputils.option

Classes

class Empty
Expand source code 
class Empty(Option):
    def get(self) -> None:
        raise ValueError("Empty Option")

    def is_defined(self) -> bool:
        return False

    def is_empty(self) -> bool:
        return True

    def __iter__(self):
        yield from ()

Generic Option type to represent a value that may or may not be present.

Ancestors

Inherited members

class Option
Expand source code 
class Option[A](metaclass=ABCMeta):
    """Generic Option type to represent a value that may or may not be present."""

    def _get_value(self) -> A:
        return self.__value

    def _set_value(self, value: A):
        self.__value = value

    _value = property(_get_value, _set_value)

    @abstractmethod
    def __iter__(self):
        """
        Returns:
            An iterator over this Option's value if this is Some,
            otherwise an empty iterator.
        """
        return NotImplemented

    @abstractmethod
    def get(self) -> A:
        """
        Returns:
            The option's value.

        raises:
            ValueError: If the option is Empty.
        """
        return NotImplemented

    @abstractmethod
    def is_defined(self) -> bool:
        """
        Returns:
            True if this is Some, False otherwise.
        """
        return NotImplemented

    @abstractmethod
    def is_empty(self) -> bool:
        """
        Returns:
            True if this is Empty, False otherwise.
        """
        return NotImplemented

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Option):
            return False
        if self.is_empty() and other.is_empty():
            return True
        if self.is_empty() != other.is_empty():
            return False
        return self.get() == other.get()

    def contains(self, value: A) -> bool:
        """
        Returns:
            True if this is Some and its value is equal to the given value, False otherwise.
        """
        return self.get() == value if self.is_defined() else False

    def exists(self, predicate: Callable[[A], bool]) -> bool:
        """
        Returns:
            False if this is Empty or returns the result of the given predicate against the Some value.
        """
        return False if self.is_empty() else predicate(self.get())

    def filter(self, predicate: Callable[[A], bool]) -> Option[A]:
        """
        Returns:
            this Option if this is Some and the given predicate does hold for the Some value,
            otherwise Empty
        """
        return self if self.is_defined() and predicate(self.get()) else Empty()

    def filter_not(self, predicate: Callable[[A], bool]) -> Option[A]:
        """
        Returns:
            this Option if this is Some and the given predicate does not hold for the Some value,
            otherwise Empty
        """
        return self if self.is_defined() and not predicate(self.get()) else Empty()

    def flatmap[B](self, f: Callable[[A], Option[B]]) -> Option[B]:
        """
        Returns:
            the result of applying f to this Option's value if this Option is non-empty,
            otherwise Empty.
        """
        return Empty() if self.is_empty() else f(self.get())

    def map[B](self, f: Callable[[A], B]) -> Option[B]:
        """
        Returns:
            the result of applying f to this Option's value if this Option is non-empty,
            otherwise Empty.
        """
        return Empty() if self.is_empty() else Some(f(self.get()))

    def flatten[B](self) -> Option[B]:
        """
        Returns:
            the nested Option's value if this is a Some,
            otherwise Empty.

        raises: AssertionError: If this is a Some and the nested value is not an Option.
        """
        if self.is_empty():
            return Empty()

        assert isinstance(self._value, Option)
        return self._value

    def fold[B](self, f: Callable[[A], B], if_empty: B) -> B:
        """
        Returns:
            if_empty if this is Empty,
            f(self.get()) if this is Some.
        """
        return if_empty if self.is_empty() else f(self.get())

    def forall(self, predicate: Callable[[A], bool]) -> bool:
        """
        Returns:
            True if this is Empty,
            True if this is Some and the given predicate holds for the Some value,
            False otherwise.
        """
        return True if self.is_empty() else predicate(self.get())

    def foreach(self, f: Callable[[A], None]) -> None:
        """
        Applies the given function to this Option's value if this Option is non-empty.
        """
        if self.is_defined():
            f(self.get())

    def get_or_else(self, other: A) -> A:
        """
        Returns:
            this Option's value if this is Some,
            other otherwise.
        """
        return self.get() if self.is_defined() else other

    def or_else(self, other: Option[A]) -> Option[A]:
        """
        Returns:
            this Option if this is Some,
            other otherwise.
        """
        return self if self.is_defined() else other

    def or_none(self) -> A | None:
        """
        Returns:
            this Option's value if this is Some,
            None otherwise.
        """
        return self.get() if self.is_defined() else None

    def to_left[B](self, right: B) -> Either[A, B]:
        """
        Returns:
            this Option's value as a Left if this is Some,
            otherwise a Right with the given value.
        """
        return Left(self.get()) if self.is_defined() else Right(right)

    def to_right[B](self, left: B) -> Either[B, A]:
        """
        Returns:
            this Option's value as a Right if this is Some,
            otherwise a Left with the given value.
        """
        return Right(self.get()) if self.is_defined() else Left(left)

    def unzip[B](self) -> tuple[Option[A], Option[B]]:
        """
        Returns:
            A pair of Options, containing non-empty values if this option is a pair and empty Options otherwise
        """
        return (
            (Some(self._value[0]), Some(self._value[1]))
            if self.is_defined() and isinstance(self.get(), tuple)
            else (Empty(), Empty())
        )

    def zip[B](self, other: Option[B]) -> Option[tuple[A, B]]:
        """
        Returns:
            A new option containing a tuple of the values of this option and the given option if both are non-empty,
            otherwise Empty.
        """
        return (
            Some((self.get(), other.get()))
            if self.is_defined() and other.is_defined()
            else Empty()
        )

Generic Option type to represent a value that may or may not be present.

Ancestors

  • typing.Generic

Subclasses

Methods

def contains(self, value: A) ‑> bool
Expand source code 
def contains(self, value: A) -> bool:
    """
    Returns:
        True if this is Some and its value is equal to the given value, False otherwise.
    """
    return self.get() == value if self.is_defined() else False

Returns

True if this is Some and its value is equal to the given value, False otherwise.

def exists(self, predicate: Callable[[A], bool]) ‑> bool
Expand source code 
def exists(self, predicate: Callable[[A], bool]) -> bool:
    """
    Returns:
        False if this is Empty or returns the result of the given predicate against the Some value.
    """
    return False if self.is_empty() else predicate(self.get())

Returns

False if this is Empty or returns the result of the given predicate against the Some value.

def filter(self, predicate: Callable[[A], bool]) ‑> Option[A]
Expand source code 
def filter(self, predicate: Callable[[A], bool]) -> Option[A]:
    """
    Returns:
        this Option if this is Some and the given predicate does hold for the Some value,
        otherwise Empty
    """
    return self if self.is_defined() and predicate(self.get()) else Empty()

Returns

this Option if this is Some and the given predicate does hold for the Some value, otherwise Empty

def filter_not(self, predicate: Callable[[A], bool]) ‑> Option[A]
Expand source code 
def filter_not(self, predicate: Callable[[A], bool]) -> Option[A]:
    """
    Returns:
        this Option if this is Some and the given predicate does not hold for the Some value,
        otherwise Empty
    """
    return self if self.is_defined() and not predicate(self.get()) else Empty()

Returns

this Option if this is Some and the given predicate does not hold for the Some value, otherwise Empty

def flatmap(self,
f: Callable[[A], Option[B]]) ‑> Option[B]
Expand source code 
def flatmap[B](self, f: Callable[[A], Option[B]]) -> Option[B]:
    """
    Returns:
        the result of applying f to this Option's value if this Option is non-empty,
        otherwise Empty.
    """
    return Empty() if self.is_empty() else f(self.get())

Returns

the result of applying f to this Option's value if this Option is non-empty, otherwise Empty.

def flatten(self) ‑> Option[B]
Expand source code 
def flatten[B](self) -> Option[B]:
    """
    Returns:
        the nested Option's value if this is a Some,
        otherwise Empty.

    raises: AssertionError: If this is a Some and the nested value is not an Option.
    """
    if self.is_empty():
        return Empty()

    assert isinstance(self._value, Option)
    return self._value

Returns

the nested Option's value if this is a Some, otherwise Empty. raises: AssertionError: If this is a Some and the nested value is not an Option.

def fold(self, f: Callable[[A], B], if_empty: B) ‑> B
Expand source code 
def fold[B](self, f: Callable[[A], B], if_empty: B) -> B:
    """
    Returns:
        if_empty if this is Empty,
        f(self.get()) if this is Some.
    """
    return if_empty if self.is_empty() else f(self.get())

Returns

if_empty if this is Empty, f(self.get()) if this is Some.

def forall(self, predicate: Callable[[A], bool]) ‑> bool
Expand source code 
def forall(self, predicate: Callable[[A], bool]) -> bool:
    """
    Returns:
        True if this is Empty,
        True if this is Some and the given predicate holds for the Some value,
        False otherwise.
    """
    return True if self.is_empty() else predicate(self.get())

Returns

True if this is Empty, True if this is Some and the given predicate holds for the Some value, False otherwise.

def foreach(self, f: Callable[[A], None]) ‑> None
Expand source code 
def foreach(self, f: Callable[[A], None]) -> None:
    """
    Applies the given function to this Option's value if this Option is non-empty.
    """
    if self.is_defined():
        f(self.get())

Applies the given function to this Option's value if this Option is non-empty.

def get(self) ‑> A
Expand source code 
@abstractmethod
def get(self) -> A:
    """
    Returns:
        The option's value.

    raises:
        ValueError: If the option is Empty.
    """
    return NotImplemented

Returns

The option's value. raises: ValueError: If the option is Empty.

def get_or_else(self, other: A) ‑> A
Expand source code 
def get_or_else(self, other: A) -> A:
    """
    Returns:
        this Option's value if this is Some,
        other otherwise.
    """
    return self.get() if self.is_defined() else other

Returns

this Option's value if this is Some, other otherwise.

def is_defined(self) ‑> bool
Expand source code 
@abstractmethod
def is_defined(self) -> bool:
    """
    Returns:
        True if this is Some, False otherwise.
    """
    return NotImplemented

Returns

True if this is Some, False otherwise.

def is_empty(self) ‑> bool
Expand source code 
@abstractmethod
def is_empty(self) -> bool:
    """
    Returns:
        True if this is Empty, False otherwise.
    """
    return NotImplemented

Returns

True if this is Empty, False otherwise.

def map(self, f: Callable[[A], B]) ‑> Option[B]
Expand source code 
def map[B](self, f: Callable[[A], B]) -> Option[B]:
    """
    Returns:
        the result of applying f to this Option's value if this Option is non-empty,
        otherwise Empty.
    """
    return Empty() if self.is_empty() else Some(f(self.get()))

Returns

the result of applying f to this Option's value if this Option is non-empty, otherwise Empty.

def or_else(self,
other: Option[A]) ‑> Option[A]
Expand source code 
def or_else(self, other: Option[A]) -> Option[A]:
    """
    Returns:
        this Option if this is Some,
        other otherwise.
    """
    return self if self.is_defined() else other

Returns

this Option if this is Some, other otherwise.

def or_none(self) ‑> A | None
Expand source code 
def or_none(self) -> A | None:
    """
    Returns:
        this Option's value if this is Some,
        None otherwise.
    """
    return self.get() if self.is_defined() else None

Returns

this Option's value if this is Some, None otherwise.

def to_left(self, right: B) ‑> Either[A, B]
Expand source code 
def to_left[B](self, right: B) -> Either[A, B]:
    """
    Returns:
        this Option's value as a Left if this is Some,
        otherwise a Right with the given value.
    """
    return Left(self.get()) if self.is_defined() else Right(right)

Returns

this Option's value as a Left if this is Some, otherwise a Right with the given value.

def to_right(self, left: B) ‑> Either[B, A]
Expand source code 
def to_right[B](self, left: B) -> Either[B, A]:
    """
    Returns:
        this Option's value as a Right if this is Some,
        otherwise a Left with the given value.
    """
    return Right(self.get()) if self.is_defined() else Left(left)

Returns

this Option's value as a Right if this is Some, otherwise a Left with the given value.

def unzip(self) ‑> tuple[Option[A], Option[B]]
Expand source code 
def unzip[B](self) -> tuple[Option[A], Option[B]]:
    """
    Returns:
        A pair of Options, containing non-empty values if this option is a pair and empty Options otherwise
    """
    return (
        (Some(self._value[0]), Some(self._value[1]))
        if self.is_defined() and isinstance(self.get(), tuple)
        else (Empty(), Empty())
    )

Returns

A pair of Options, containing non-empty values if this option is a pair and empty Options otherwise

def zip(self,
other: Option[B]) ‑> Option[tuple[A, B]]
Expand source code 
def zip[B](self, other: Option[B]) -> Option[tuple[A, B]]:
    """
    Returns:
        A new option containing a tuple of the values of this option and the given option if both are non-empty,
        otherwise Empty.
    """
    return (
        Some((self.get(), other.get()))
        if self.is_defined() and other.is_defined()
        else Empty()
    )

Returns

A new option containing a tuple of the values of this option and the given option if both are non-empty, otherwise Empty.

class Some (value: A)
Expand source code 
class Some[A](Option[A]):
    def __init__(self, value: A):
        self._value = value

    def get(self) -> A:
        return self._value

    def is_defined(self) -> bool:
        return True

    def is_empty(self) -> bool:
        return False

    def __iter__(self):
        yield self._value

Generic Option type to represent a value that may or may not be present.

Ancestors

Inherited members