Question

I am looking for the most common way to do something like:

x :: IO ((),[SomeException])
x = do
  void y
  void z

aggregating exceptions that may be thrown by y and z and returning them as part of the type of x.

Is there a well-known monad / tutorial for this?

Answer 1

So the important question here is augustss – “If y throws an exception, what would the value of a be?”

If you have default values for a, and b, you can use try to catch your exceptions and aggregate them using WriterT:

x :: IO (C, [SomeException])
x = runWriterT $ do 
  a <- rescue defaultA y 
  b <- rescue defaultB z 
  return $ f a b

rescue :: a -> IO a -> WriterT [SomeException] IO a
rescue a m = do
  res <- lift $ try m
  case res of
    Left e -> do
      tell [e]
      return a
    Right a' -> return a'

data A
data B
data C

y :: IO A
y = undefined

defaultA :: A
defaultA = undefined

z :: IO B
z = undefined

defaultB :: B
defaultB = undefined

f :: A -> B -> C
f = undefined

Without defaults though, you can’t rescue exceptions and continue computation.