Typing issue with chained Result

Take the following two functions as an example of two (or more) functions with unique failure modes (each function may fail in their own way)

def fraction(x: float ) -> Result[float, ZeroDivisionError]:
    try: return Success(1/x)
    except ZeroDivisionError as e: return Failure(e)

def log_of_arg_minus_one(x: float) -> Result[float, ValueError]:
    try: return Success(log(1-x))
    except ValueError as e: return Failure(e)

then a computation like fraction(x).bind(log_of_arg_minus_one) has potentially three different outcomes:

1. the happy path where both functions return a Success, i.e. fraction(x) returns Success(y) where y is a float and log_of_arg_minus_one(y) returns Success(z) where z is also a float; example fraction(2).bind(log_of_arg_minus_one)
2. the failure path of fraction , i.e. Failure(ZeroDivisionError); example: fraction(0).bind(log_of_arg_minus_one)
3. the failure path of log_of_arg_minus_one, i.e. Failure(ValueError); example: fraction(1).bind(log_of_arg_minus_one)

Sadly this seems not to type correctly:

FailureCases = Union[ZeroDivisionError, ValueError]

z: Result[float, FailureCases] = fraction(1).bind(log_of_arg_minus_one)

# Argument 1 to "bind" of "Result" has incompatible type 
# "Callable[[float], Result[float, ValueError]]"; 
# expected "Callable[[float], Result[float, Union[ZeroDivisionError, ValueError]]]"

The following also doesn’t work:

z: Result[float, Exception] = fraction(1).bind(log_of_arg_minus_one)

# Argument 1 to "bind" of "Result" has incompatible type 
# "Callable[[float], Result[float, ValueError]]"; 
# expected "Callable[[float], Result[float, Exception]]"

I don’t know it this is an issue with bind (that might be fixable with a plugin) or just that Result[S, F] is not properly covariant with respect to F i.e. Result[X, A] is considered a subtype of Result[X, B] when A is a subtype of B

[stereobutter]

@sobolevn I think a better name for the type aggregating bind might be chain (instead of unify)

[stereobutter]

Another general issue with the typing of Result that I originally mentioned in this issue (but that turned out be unrelated) is covariance. Consider:

z: Result[float, Exception] = Success(1).bind(fraction).bind(log_of_arg_minus_one)

As it currently is (regardless of the original or the proposed behavior) this doesn’t typecheck. I think it should?