Pipe

class Pipe(Protocol):
    """Mixin class providing the `pipe` method for fluent chaining."""
    def pipe[**P, R](
        self,
        func: Callable[Concatenate[Self, P], R],
        *args: P.args,
        **kwargs: P.kwargs,
    ) -> R:
        """Convert `Self` to `R`.

        This method allows to pipe the instance into an object or function that can convert `Self` into another type.

        Conceptually, this allow to do `x.pipe(f)` instead of `f(x)`, hence keeping a fluent chaining style.

        Args:
            func (Callable[Concatenate[Self, P], R]): Function for conversion.
            *args (P.args): Positional arguments to pass to **func**.
            **kwargs (P.kwargs): Keyword arguments to pass to **func**.

        Returns:
            R: The converted value.

        Example:
            ```python
            from pyochain import Seq, Result, Ok, Err
            from collections.abc import Sequence

            def check_data(data: Sequence[int]) -> Result[Sequence[int], str]:
                if len(data) == 0:
                    return Err("Empty data")
                return Ok(data)

            def handle_result(res: Result[Sequence[int], str]) -> str:
                match res:
                    case Ok(data):
                        return f"Data is valid: {data}"
                    case Err(err):
                        return f"Data is invalid: {err}"

            x = Seq(1, 2, 3).pipe(check_data).pipe(handle_result)
            assert x == "Data is valid: Seq(1, 2, 3)"
            ```
        """