Unwrapping failures erases exception type information

Let’s say I unwrap a failure and want to catch it using try-except.

The only way to do so currently is:

from returns.result import Result
from returns.functions import safe
from returns.primitives.exceptions import UnwrapFailedError

@safe
def foo(i) -> Result[int, Exception]:
  if i == 0:
    raise ValueError("problem")
  return i + 5

try:
  result = foo('a') # Will raise TypeError
  # do stuff
  result.unwrap()
except UnwrapFailedError as e:
  try:
    raise e.halted_container.failure() from e
  except ValueError:
    print("Don't use zero")
  except TypeError:
    print("Dont use strings")

This makes exception handling code more complex than it should be.

Naturally you could have also used:

@safe
def handle_err(e) -> Result[None, Exception]:
  if isinstance(e, ValueError):
    print("Don't use zero")
  elif isinstance(e, TypeError):
    print("Dont use strings")
  else:
    raise e from e

try:
  foo('a').rescue(handle_err).unwrap()
except UnwrapFailedError:
  print("Unhandled exception!!!")

But the error handling code above simply feels unpythonic and awkward.

Rescuing from an error fits the usecase where you want to log the error and proceed or any other generic error handling situation.

You could make rescue() accept a mapping between types to callables and call the appropriate error handler when an exception occured but I don’t see why you’d have to do so.

It seems to me that the UnwrapFailedError exception is not necessary and hinders code readability. The try-except clause was created for such situations. We should use it.

[sobolevn]

Now it is result.alt(raise_exception).unwrap()

[sobolevn]

@thedrow I like unwrap_or_raise()!