Why exception is not catching by `catch`? - haskell

Question

Why does not this catch exception of conversion conv B3 ?!
import qualified Control.Monad.Catch as E
data A = A1|A2 deriving (Enum, Show)
data B = B1|B2|B3 deriving (Enum, Show)
conv b = safeConv
where
catchError e = Left e
safeConv = (Right $ (toEnum $ fromEnum b :: A)) `E.catch` catchError
I got:
Right *** Exception: toEnum{A}: tag (2) is outside of enumeration's range (0,1)
CallStack (from HasCallStack):
error, called at xxx.hs:227:26 in main:Main

Answer 1

Haskell exceptions are somewhat different than, say, Java or C++: "true" exceptions work in IO monad, and then there is an imitation of exceptions via pure means, as in ExceptT.
The toEnum function throws the first kind - IO exceptions, - which cannot be caught in pure code. They fly out to the nearest IO place, which in your case is apparently GHCi.
In order to catch such exceptions, you first need to wrap the throwing expression in IO via Control.Exception.evaluate. Then you can catch such exceptions with catch, or, if you just want to convert it to an Either exception A (as you seem to be doing), there is an app for that! - it's called try.
Further, when using either catch or try, you need to specify the specific type of the exception you're trying to catch. But it is possible to catch all exceptions regardless of type by using the existential type SomeException.
So, wrapping up all of that, we get this code:
import qualified Control.Exception as E
data A = A1|A2 deriving (Enum, Show)
data B = B1|B2|B3 deriving (Enum, Show)
conv :: Enum b => b -> IO (Either E.SomeException A)
conv b = E.try . E.evaluate . toEnum $ fromEnum b
NOTE 1: The type annotation on conv is necessary in order to specify E.SomeException as the type of exception to catch. Without it, GHC will complain that the type of exception is ambiguous.
NOTE 2: Because our type annotation on conv already specifies the target type A, the type annotation on toEnum $ fromEnum b is no longer necessary.
NOTE 3: I have replaced your import of Control.Monad.Catch with Control.Exception, because that's where evaluate and SomeException are.

Answer 2

I'll leave it here if someone needs a solution. To keep function pure, conversion should be:
unsafeConvEnum :: (Enum a, Enum b) => a -> b
unsafeConvEnum = toEnum . fromEnum
convEnum :: (Enum a, Enum b) => a -> Maybe b
convEnum e = unsafePerformIO conv'
where onError (_::SomeException) = pure Nothing
conv' = (Just <$> evaluate (unsafeConvEnum e)) `catch` onError
No any IO :)