Better handle exceptions catchs

[OutSquareCapital]

Currently, try:...except:... blocks are still needed to catch exceptions and wrap them in Err. We should find an API design that allows us to completely avoid this.

The issue with a simple func f(Callable[[T], R], *exceptions: E) -> Result[T,E] is that this don't allow ParamSpec to be used here, making the API not convenient on many cases.

A builder in two step could be an idea.

But how to implement a try catch in Rust?

[OutSquareCapital]

Here is a few experiments.

Everything type safe and work as intended.

The hack with __new__ won't be a problem once in Rust.

We could add catch_from1 for *args only and catch_from0 for no args at all.

from __future__ import annotations

from dataclasses import dataclass
from functools import wraps
from typing import TYPE_CHECKING, Any

from pyochain import NONE, Err, Iter, Ok, Option, Result, Some, Vec

if TYPE_CHECKING:
    from collections.abc import Callable, Generator, Iterable


def into_iter[**P, T](fn: Callable[P, Iterable[T]]) -> Callable[P, Iter[T]]:
    @wraps(fn)
    def wrapper(*args: P.args, **kwargs: P.kwargs) -> Iter[T]:
        return Iter(fn(*args, **kwargs))

    return wrapper


@into_iter
def foo(x: int, y: int, z: int) -> Generator[int, Any]:
    yield x
    yield y
    yield z
    yield from [1, 2, 3]


class Catch[*E]:
    __slots__ = ("exceptions",)  # pyright: ignore[reportUnannotatedClassAttribute]
    exceptions: tuple[type[BaseException], ...]  # pyright: ignore[reportUninitializedInstanceVariable]

    # NOTE: needed to go around limitations regarding bounds on TypeVarTuples
    def __new__[T: BaseException](cls, *exceptions: type[T]) -> Catch[*T]:  # pyright: ignore[reportInvalidTypeForm]
        self = super().__new__(cls)
        self.exceptions = exceptions
        return self  # pyright: ignore[reportReturnType]

    def __call__[**P, R](self, f: Callable[P, R]) -> Callable[P, Result[R, E]]:
        @wraps(f)
        def decorator(
            *args: P.args,
            **kwargs: P.kwargs,
        ) -> Result[R, E]:
            try:
                return Ok(f(*args, **kwargs))
            except self.exceptions as exc:
                return Err(exc)  # pyright: ignore[reportReturnType]

        return decorator

    def catch_from[**P, R](
        self, f: Callable[P, R], *args: P.args, **kwargs: P.kwargs
    ) -> Result[R, E]:
        try:
            return Ok(f(*args, **kwargs))
        except self.exceptions as exc:
            return Err(exc)  # pyright: ignore[reportReturnType]


@dataclass(slots=True)
class Bool:
    b: object

    def __bool__(self) -> bool:
        return bool(self.b)

    def ok_or[E](self, err: E) -> Result[None, E]:
        if self.b:
            return Ok(None)
        else:
            return Err(err)

    def ok_or_else[E](self, f: Callable[[], E]) -> Result[None, E]:
        if self.b:
            return Ok(None)
        else:
            return Err(f())

    def then[T](self, f: Callable[[], T]) -> Option[T]:
        if self.b:
            return Some(f())
        else:
            return NONE

    def then_some[T](self, t: T) -> Option[T]:
        if self.b:
            return Some(t)
        else:
            return NONE


errs = Catch(ZeroDivisionError, TypeError)


@errs
def bar(x: int, y: int, z: int) -> float:
    return x / y / z


x = foo(1, 2, 3)
y = bar(1, 2, "str")  # pyright: ignore[reportArgumentType]
y2 = bar(1, 2, 0)
print(y)
z = errs.catch_from(lambda: 1 / 0)
print(z)
# Comparing actual checkable API with potential new When API
x = Vec([1, 2, 3]).pipe(Bool).ok_or("error")
y = Vec([1, 2, 3]).ok_or("error")