PyoSet

class PyoSet[T](PyoCollection[T], AbstractSet[T]):
    """Base trait for eager pyochain set-like collections.

    `PyoSet[T]` is the shared trait for concrete, eager set-like
    collections: `Set` and `FrozenSet`.

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

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

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

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

    """

    __slots__ = ()

    def is_subset(self, other: AbstractSet[T]) -> bool:
        """Check if the `Set` is a subset of another set.

        Args:
            other (AbstractSet[T]): The other set to compare with.

        Returns:
            bool: True if the `Set` is a subset of the other set, False otherwise.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2}).is_subset({1, 2, 3})
        True
        >>> pc.Set({1, 4}).is_subset({1, 2, 3})
        False

        ```
        """
        return self <= other

    def is_subset_strict(self, other: AbstractSet[T]) -> bool:
        """Check if the `Set` is a proper subset of another set.

        Args:
            other (AbstractSet[T]): The other set to compare with.

        Returns:
            bool: `True` if the `Set` is a proper subset of the other set, `False` otherwise.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2}).is_subset_strict({1, 2, 3})
        True
        >>> pc.Set({1, 2}).is_subset_strict({1, 2})
        False

        ```
        """
        return self < other

    def eq(self, other: AbstractSet[T]) -> bool:
        """Check if the `Set` is equal to another set.

        Args:
            other (AbstractSet[T]): The other set to compare with.

        Returns:
            bool: True if the `Set` is equal to the other set, False otherwise.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2}).eq({2, 1})
        True
        >>> pc.Set({1, 2}).eq({1, 2, 3})
        False

        ```
        """
        return self == other

    def is_superset(self, other: AbstractSet[T]) -> bool:
        """Check if the `Set` is a superset of another set.

        Args:
            other (AbstractSet[T]): The other set to compare with.

        Returns:
            bool: True if the `Set` is a superset of the other set, False otherwise.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2, 3}).is_superset({1, 2})
        True
        >>> pc.Set({1, 2}).is_superset({1, 2, 3})
        False

        ```
        """
        return self >= other

    def intersection(self, other: AbstractSet[T]) -> Self:
        """Return the intersection of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to intersect with.

        Returns:
            Self: A new `Set` containing the intersection of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2, 2}).intersection({2, 3})
        Set(2,)

        ```
        """
        return self.__class__(self & other)

    def r_intersection(self, other: AbstractSet[T]) -> Self:
        """Return the intersection of another set with the `Set`.

        Args:
            other (AbstractSet[T]): The other set to intersect with.

        Returns:
            Self: A new `Set` containing the intersection of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({2, 3}).r_intersection({1, 2})
        Set(2,)

        ```
        """
        return self.__class__(other & self)

    def union(self, other: AbstractSet[T]) -> Self:
        """Return the union of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to unite with.

        Returns:
            Self: A new `Set` containing the union of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2, 2}).union([2, 3]).union([4]).iter().sort()
        Vec(1, 2, 3, 4)

        ```
        """
        return self.__class__(self | other)

    def r_union(self, other: AbstractSet[T]) -> Self:
        """Return the union of another set with the `Set`.

        Args:
            other (AbstractSet[T]): The other set to unite with.

        Returns:
            Self: A new `Set` containing the union of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({2, 3}).r_union({1, 2}).iter().sort()
        Vec(1, 2, 3)

        ```
        """
        return self.__class__(other | self)

    def difference(self, other: AbstractSet[T]) -> Self:
        """Return the difference of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to subtract.

        Returns:
            Self: A new `Set` containing the difference of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2, 2}).difference([2, 3])
        Set(1,)

        ```
        """
        return self.__class__(self - other)

    def r_difference(self, other: AbstractSet[T]) -> Self:
        """Return the reverse difference of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to subtract from.

        Returns:
            Self: A new `Set` containing the reverse difference of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({2, 3}).r_difference({1, 2})
        Set(1,)

        ```
        """
        return self.__class__(other - self)

    def symmetric_difference(self, other: AbstractSet[T]) -> Self:
        """Return the symmetric difference of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to symmetric difference with.

        Returns:
            Self: A new `Set` containing the symmetric difference of the two sets.
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2, 2}).symmetric_difference([2, 3]).iter().sort()
        Vec(1, 3)
        >>> pc.Set({1, 2, 3}).symmetric_difference([3, 4, 5]).iter().sort()
        Vec(1, 2, 4, 5)

        ```
        """
        return self.__class__(self ^ other)

    def r_symmetric_difference(self, other: AbstractSet[T]) -> Self:
        """Return the symmetric difference of the `Set` with another set.

        Args:
            other (AbstractSet[T]): The other set to symmetric difference with.

        Returns:
            Self: A new `Set` containing the symmetric difference of the two sets.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({2, 3}).r_symmetric_difference({1, 2}).iter().sort()
        Vec(1, 3)

        ```
        """
        return self.__class__(other ^ self)

    def is_disjoint(self, other: AbstractSet[T]) -> bool:
        """Check if the `Set` has no elements in common with another set.

        Args:
            other (AbstractSet[T]): The other set to compare with.

        Returns:
            bool: True if the `Set` and the other set have no elements in common, False otherwise.

        Example:
        ```python
        >>> import pyochain as pc
        >>> pc.Set({1, 2}).is_disjoint({3, 4})
        True
        >>> pc.Set({1, 2}).is_disjoint({2, 3})
        False

        ```
        """
        return self.isdisjoint(other)