So, I've had a number of issues with exceptions. This has been one of them. I don't really like this proposal as it stands though as it seems to make catch a specific exception with said extra info more difficult.

This is data Control.Exception can move around on its own though, right? The problem really isn't passing it internal, we could just make a (Stack, SomeException) tuple just fine, in theory I think (I'll admit I've not actually reviewed the code, and this isn't meant as a complete proposal but more a thought experiment). The problem is code handling the data and working with old code while not losing any of the power of the current system.

So we start with: catch :: Exception e => IO a -> (e -> IO a) -> IO a

Now this proposal allows: catch :: IO a -> (SomeException -> IO a) -> IO a

If we want access to the new information, but that's not really satisfactory.

Real code regularly wants to (picking an arbitrary instance of Exception) do: catch :: IO a -> (IOError -> IO a) -> IO a 

only we still want new data.

Now one could do something like: catch :: IO a -> (Stack -> IOError -> IO a) -> IO a

but that is not very upgradable and it breaks existing code.

But this is just a matter of requesting information, so one could do something like: catch :: IO a -> (WithStack IOError -> IO a) -> IO a

where: data WithStack e = WithStack Stack e

Or maybe one just addes: catchWithContext :: Exception e => IO a -> (Context -> e -> IO a) -> IO a

Or: catchWithContext :: Exception => IO a -> (Context e -> IO a) -> IO a

Now existing code continues to run and we can feed our exception handlers the data they want, even when we want some specific exception instead of just any exception.