u/a_deneb First of all, really nice helper! I like everything the library provides, but I'd like to make a suggestion since we can leverage python a bit more here. Why not merge `safe` and `safe_with` as one decorator. Then you can use `typing.overload` to annotate the case where the arguments are exceptions and the cases where the argument is a single function. Something like:

@overload
def safe(func: Callable[P, R]) -> Callable[P, Result[R, Exception]]: ...


@overload
def safe(
    *exc_types: Type[ExcType]
) -> Callable[[Callable[P, R]], Callable[P, Result[R, ExcType]]]: ...


def safe(
    *args: Any
) -> Union[Callable[P, Result[R, Exception]], Callable[[Callable[P, R]], Callable[P, Result[R, ExcType]]]]:
    """
    A flexible decorator that wraps a function to return a `Result`.

    Can be used in two ways:

    1. As a direct decorator:
       >>> @safe
       ... def divide(a: int, b: int) -> float:
       ...     return a / b
       ...
       >>> result = divide(10, 0)  # -> `Result[float, Exception]`

    2. As a decorator factory with specified exception types:
       >>> @safe(ZeroDivisionError, ValueError)
       ... def divide(a: int, b: int) -> float:
       ...     return a / b
       ...
       >>> result = divide(10, 0)  # -> `Result[float, ZeroDivisionError | ValueError]`
    """
    # Case 1: @safe used directly on a function
    # Implementation ...

    # Case 2: @safe(ExcType1, ExcType2, ...) used as a decorator factory
    # Implementation ...

    return decorator