PyoSequence

class PyoSequence[T](PyoCollection[T], Sequence[T]):
    """Base trait for eager pyochain sequences.

    `PyoSequence[T]` is the shared trait for concrete, eager sequence-like
    collections: `Seq` and `Vec`.

    It extends `PyoCollection[T]` and `collections.abc.Sequence[T]`.

    This is equivalent to subclassing `collections.abc.Sequence[T]` (this trait
    already does), meaning any concrete subclass must implement the required
    `Sequence` dunder methods:

    - `__getitem__`
    - `__len__`
    - `__contains__`
    - `__iter__`

    On top of the standard `Sequence` protocol, it provides the additional
    pyochain API (from `PyoCollection`, `Pipeable`, `Checkable`, plus any helpers defined here).

    """

    __slots__ = ()

    @overload
    def get(self, index: int) -> Option[T]: ...
    @overload
    def get(self, index: slice) -> Option[Sequence[T]]: ...
    def get(self, index: int | slice) -> Option[T] | Option[Sequence[T]]:
        """Return the element at the specified index as `Some(value)`, or `None` if the index is out of bounds.

        Args:
            index (int | slice): The index or slice of the element to retrieve.

        Returns:
            Option[T] | Option[Sequence[T]]: `Some(value)` if the index is valid, otherwise `None`.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Seq([10, 20, 30]).get(1)
        Some(20)
        >>> pc.Seq([10, 20, 30]).get(5)
        NONE

        ```
        """
        try:
            return Some(self.__getitem__(index))  # pyright: ignore[reportReturnType]
        except IndexError:
            return NONE

    def rev(self) -> Iter[T]:
        """Return an `Iterator` with the elements of the `Sequence` in reverse order.

        Returns:
            Iter[T]: An `Iterator` with the elements in reverse order.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Seq([1, 2, 3]).rev().collect()
        Seq(3, 2, 1)

        ```
        """
        from .._iter import Iter

        return Iter(reversed(self))

    def is_distinct(self) -> bool:
        """Return True if all items of the `Sequence` are distinct.

        Returns:
            bool: True if all items are distinct, False otherwise.

        ```python
        >>> import pyochain as pc
        >>> pc.Seq([1, 2]).is_distinct()
        True

        ```
        """
        return cz.itertoolz.isdistinct(self)