Exceptions

[Simon Marlow]

[oops, sent by accident...]

On 08 April 2006 10:18, John Meacham wrote:

> On Sat, Apr 08, 2006 at 12:11:51AM -0400, David Menendez wrote:
>>> newtype ArithException a = ArithException a
>>> 
>>> data DivideByZero
>>> 
>>> throw (ArithException DivideByZero)
>>> 
>>> your code:
>>> 
>>> data MultiplyByZero
>>> throw (ArithException MultiplyByZero)
>> 
>> How would you use this to write a handler that captures any
>> ArithException?
> 
> You would use the Typeable1 class in Data.Typeable. not perfect, but
> exception hierarchies shouldn't be too deep so it is not so bad.

I mentioned this solution to John G. off-list; the problem is that you
end up needing to parameterise all the classes of exceptions (we'd have
IOException a, ArrayException a, AsyncException a, etc.), and that seems
ugly.

Given that we've already made the Exception type sideways extensible
with a simple application of type classes and dynamic types, we can take
the technique a bit further to create an extensible hierarchy of
exceptions, which is what John's arguing for.

To create a new subclass of exceptions:

---------
class (Typeable x, Show x) => ArithException x

newtype AnyArithException = AnyArithException Dynamic
  deriving Typeable

instance Exception AnyArithException
instance Show AnyArithException where
  show (AnyArithException x) = show x

throwArith :: ArithException x => x -> a
throwArith x = throw (AnyArithException (toDyn x))

matchArith :: ArithException x => AnyArithException -> Maybe x
matchArith (AnyArithException x) = fromDynamic x
---------

and populating the subclass is just as easy as populating the root:

---------
data DivideByZero = DivideByZero deriving (Typeable, Show)
data Overflow     = Overflow     deriving (Typeable, Show)

instance ArithException DivideByZero
instance ArithException Overflow
---------

catching is easy too.  To catch *any* ArithException:

---------
     x `catch` \(e :: AnyArithException) -> print e
---------

To catch a particular ArithException:

---------
     x `catch` 
         \e -> case () of
                 _ | Just DivideByZero <- matchArith e -> print e
                   | otherwise -> throw e
---------

To catch a mixture of ArithException and other exceptions:

---------
  x `catchAny` 
    \e -> case () of
 		_ | Just (IOException x) <- matchException e -> print x
		  | Just arith <- matchException e, 
		    Just DivideByZero <- matchArith arith -> print arith
		  | otherwise -> throwAny e
---------

I like this, it seems like a natural extension of what we've already
proposed.  The fact that you have to use 'throwArith' rather than plain
'throw' is slightly annoying, though.

Cheers,
	Simon