PyoMapping

class PyoMapping[K, V](PyoCollection[K], Mapping[K, V]):
    """Base trait for eager pyochain immutable mapping collections.

    `PyoMapping[K, V]` is the shared trait for concrete, eager mapping-like
    collections such as `Dict`.

    It extends `PyoCollection[K]` and `collections.abc.Mapping[K, V]`.

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

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

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

    __slots__ = ()

    def keys(self) -> PyoKeysView[K]:
        """Return a view of the `Mapping` keys.

        Returns:
            PyoKeysView[K]: A view of the dictionary's keys.

        Example:
        ```python
        >>> import pyochain as pc
        >>> data = pc.Dict({1: "a", 2: "b"})
        >>> data.keys()
        PyoKeysView(Dict(1: 'a', 2: 'b'))

        ```
        """
        return PyoKeysView(self)

    def values(self) -> PyoValuesView[V]:
        """Return a view of the `Mapping` values.

        Returns:
            PyoValuesView[V]: A view of the dictionary's values.

        Example:
        ```python
        >>> import pyochain as pc
        >>> data = pc.Dict({1: "a", 2: "b"})
        >>> data.values()
        PyoValuesView(Dict(1: 'a', 2: 'b'))

        ```
        """
        return PyoValuesView(self)

    def items(self) -> PyoItemsView[K, V]:
        """Return a view of the `Mapping` items.

        Returns:
            PyoItemsView[K, V]: A view of the dictionary's (key, value) pairs.

        Example:
        ```python
        >>> import pyochain as pc
        >>> data = pc.Dict({1: "a", 2: "b"})
        >>> data.items()
        PyoItemsView(Dict(1: 'a', 2: 'b'))

        ```
        """
        return PyoItemsView(self)