1 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
5 -----------------------------------------------------------------------------
7 -- Module : Control.OldException
8 -- Copyright : (c) The University of Glasgow 2001
9 -- License : BSD-style (see the file libraries/base/LICENSE)
11 -- Maintainer : libraries@haskell.org
12 -- Stability : experimental
13 -- Portability : non-portable (extended exceptions)
15 -- This module provides support for raising and catching both built-in
16 -- and user-defined exceptions.
18 -- In addition to exceptions thrown by 'IO' operations, exceptions may
19 -- be thrown by pure code (imprecise exceptions) or by external events
20 -- (asynchronous exceptions), but may only be caught in the 'IO' monad.
21 -- For more details, see:
23 -- * /A semantics for imprecise exceptions/, by Simon Peyton Jones,
24 -- Alastair Reid, Tony Hoare, Simon Marlow, Fergus Henderson,
27 -- * /Asynchronous exceptions in Haskell/, by Simon Marlow, Simon Peyton
28 -- Jones, Andy Moran and John Reppy, in /PLDI'01/.
30 -----------------------------------------------------------------------------
32 module Control.OldException (
34 -- * The Exception type
35 Exception(..), -- instance Eq, Ord, Show, Typeable
36 New.IOException, -- instance Eq, Ord, Show, Typeable
37 New.ArithException(..), -- instance Eq, Ord, Show, Typeable
38 New.ArrayException(..), -- instance Eq, Ord, Show, Typeable
39 New.AsyncException(..), -- instance Eq, Ord, Show, Typeable
41 -- * Throwing exceptions
42 throwIO, -- :: Exception -> IO a
43 throw, -- :: Exception -> a
44 ioError, -- :: IOError -> IO a
45 #ifdef __GLASGOW_HASKELL__
46 -- XXX Need to restrict the type of this:
47 New.throwTo, -- :: ThreadId -> Exception -> a
50 -- * Catching Exceptions
52 -- |There are several functions for catching and examining
53 -- exceptions; all of them may only be used from within the
56 -- ** The @catch@ functions
57 catch, -- :: IO a -> (Exception -> IO a) -> IO a
58 catchJust, -- :: (Exception -> Maybe b) -> IO a -> (b -> IO a) -> IO a
60 -- ** The @handle@ functions
61 handle, -- :: (Exception -> IO a) -> IO a -> IO a
62 handleJust,-- :: (Exception -> Maybe b) -> (b -> IO a) -> IO a -> IO a
64 -- ** The @try@ functions
65 try, -- :: IO a -> IO (Either Exception a)
66 tryJust, -- :: (Exception -> Maybe b) -> a -> IO (Either b a)
68 -- ** The @evaluate@ function
69 evaluate, -- :: a -> IO a
71 -- ** The @mapException@ function
72 mapException, -- :: (Exception -> Exception) -> a -> a
74 -- ** Exception predicates
78 ioErrors, -- :: Exception -> Maybe IOError
79 arithExceptions, -- :: Exception -> Maybe ArithException
80 errorCalls, -- :: Exception -> Maybe String
81 dynExceptions, -- :: Exception -> Maybe Dynamic
82 assertions, -- :: Exception -> Maybe String
83 asyncExceptions, -- :: Exception -> Maybe AsyncException
84 userErrors, -- :: Exception -> Maybe String
86 -- * Dynamic exceptions
89 throwDyn, -- :: Typeable ex => ex -> b
90 #ifdef __GLASGOW_HASKELL__
91 throwDynTo, -- :: Typeable ex => ThreadId -> ex -> b
93 catchDyn, -- :: Typeable ex => IO a -> (ex -> IO a) -> IO a
95 -- * Asynchronous Exceptions
99 -- ** Asynchronous exception control
101 -- |The following two functions allow a thread to control delivery of
102 -- asynchronous exceptions during a critical region.
104 block, -- :: IO a -> IO a
105 unblock, -- :: IO a -> IO a
107 -- *** Applying @block@ to an exception handler
111 -- *** Interruptible operations
117 assert, -- :: Bool -> a -> a
121 bracket, -- :: IO a -> (a -> IO b) -> (a -> IO c) -> IO ()
122 bracket_, -- :: IO a -> IO b -> IO c -> IO ()
125 finally, -- :: IO a -> IO b -> IO a
127 #ifdef __GLASGOW_HASKELL__
128 setUncaughtExceptionHandler, -- :: (Exception -> IO ()) -> IO ()
129 getUncaughtExceptionHandler -- :: IO (Exception -> IO ())
133 #ifdef __GLASGOW_HASKELL__
137 import GHC.IOBase ( IO )
138 import GHC.IOBase (catchException)
139 import qualified GHC.IOBase as ExceptionBase
140 import qualified GHC.IOBase as New
141 import GHC.Conc hiding (setUncaughtExceptionHandler,
142 getUncaughtExceptionHandler)
143 import Data.IORef ( IORef, newIORef, readIORef, writeIORef )
144 import Foreign.C.String ( CString, withCString )
145 import GHC.Handle ( stdout, hFlush )
149 import Prelude hiding (catch)
150 import Hugs.Prelude as New (ExitCode(..))
153 import qualified Control.Exception as New
154 import Control.Exception ( throw, SomeException, block, unblock, evaluate, throwIO )
155 import System.IO.Error hiding ( catch, try )
156 import System.IO.Unsafe (unsafePerformIO)
162 import System.IO.Error (catch, ioError)
164 import DIOError -- defn of IOError type
166 -- minimum needed for nhc98 to pretend it has Exceptions
167 type Exception = IOError
168 type IOException = IOError
173 throwIO :: Exception -> IO a
175 throw :: Exception -> a
176 throw = unsafePerformIO . throwIO
178 evaluate :: a -> IO a
179 evaluate x = x `seq` return x
181 ioErrors :: Exception -> Maybe IOError
183 arithExceptions :: Exception -> Maybe ArithException
184 arithExceptions = const Nothing
185 errorCalls :: Exception -> Maybe String
186 errorCalls = const Nothing
187 dynExceptions :: Exception -> Maybe Dynamic
188 dynExceptions = const Nothing
189 assertions :: Exception -> Maybe String
190 assertions = const Nothing
191 asyncExceptions :: Exception -> Maybe AsyncException
192 asyncExceptions = const Nothing
193 userErrors :: Exception -> Maybe String
194 userErrors (UserError _ s) = Just s
195 userErrors _ = Nothing
197 block :: IO a -> IO a
199 unblock :: IO a -> IO a
202 assert :: Bool -> a -> a
204 assert False _ = throw (UserError "" "Assertion failed")
207 -----------------------------------------------------------------------------
208 -- Catching exceptions
210 -- |This is the simplest of the exception-catching functions. It
211 -- takes a single argument, runs it, and if an exception is raised
212 -- the \"handler\" is executed, with the value of the exception passed as an
213 -- argument. Otherwise, the result is returned as normal. For example:
215 -- > catch (openFile f ReadMode)
216 -- > (\e -> hPutStr stderr ("Couldn't open "++f++": " ++ show e))
218 -- For catching exceptions in pure (non-'IO') expressions, see the
219 -- function 'evaluate'.
221 -- Note that due to Haskell\'s unspecified evaluation order, an
222 -- expression may return one of several possible exceptions: consider
223 -- the expression @error \"urk\" + 1 \`div\` 0@. Does
224 -- 'catch' execute the handler passing
225 -- @ErrorCall \"urk\"@, or @ArithError DivideByZero@?
227 -- The answer is \"either\": 'catch' makes a
228 -- non-deterministic choice about which exception to catch. If you
229 -- call it again, you might get a different exception back. This is
230 -- ok, because 'catch' is an 'IO' computation.
232 -- Note that 'catch' catches all types of exceptions, and is generally
233 -- used for \"cleaning up\" before passing on the exception using
234 -- 'throwIO'. It is not good practice to discard the exception and
235 -- continue, without first checking the type of the exception (it
236 -- might be a 'ThreadKilled', for example). In this case it is usually better
237 -- to use 'catchJust' and select the kinds of exceptions to catch.
239 -- Also note that the "Prelude" also exports a function called
240 -- 'Prelude.catch' with a similar type to 'Control.OldException.catch',
241 -- except that the "Prelude" version only catches the IO and user
242 -- families of exceptions (as required by Haskell 98).
244 -- We recommend either hiding the "Prelude" version of 'Prelude.catch'
245 -- when importing "Control.OldException":
247 -- > import Prelude hiding (catch)
249 -- or importing "Control.OldException" qualified, to avoid name-clashes:
251 -- > import qualified Control.OldException as C
253 -- and then using @C.catch@
256 catch :: IO a -- ^ The computation to run
257 -> (Exception -> IO a) -- ^ Handler to invoke if an exception is raised
260 -- We need to catch all the sorts of exceptions that used to be
261 -- bundled up into the Exception type, and rebundle them for the
262 -- legacy handler we've been given.
264 [New.Handler (\e -> handler e),
265 New.Handler (\exc -> handler (ArithException exc)),
266 New.Handler (\exc -> handler (ArrayException exc)),
267 New.Handler (\(New.AssertionFailed err) -> handler (AssertionFailed err)),
268 New.Handler (\exc -> handler (AsyncException exc)),
269 New.Handler (\New.BlockedOnDeadMVar -> handler BlockedOnDeadMVar),
270 New.Handler (\New.BlockedIndefinitely -> handler BlockedIndefinitely),
271 New.Handler (\New.NestedAtomically -> handler NestedAtomically),
272 New.Handler (\New.Deadlock -> handler Deadlock),
273 New.Handler (\exc -> handler (DynException exc)),
274 New.Handler (\(New.ErrorCall err) -> handler (ErrorCall err)),
275 New.Handler (\exc -> handler (ExitException exc)),
276 New.Handler (\exc -> handler (IOException exc)),
277 New.Handler (\(New.NoMethodError err) -> handler (NoMethodError err)),
278 New.Handler (\New.NonTermination -> handler NonTermination),
279 New.Handler (\(New.PatternMatchFail err) -> handler (PatternMatchFail err)),
280 New.Handler (\(New.RecConError err) -> handler (RecConError err)),
281 New.Handler (\(New.RecSelError err) -> handler (RecSelError err)),
282 New.Handler (\(New.RecUpdError err) -> handler (RecUpdError err))]
284 -- | The function 'catchJust' is like 'catch', but it takes an extra
285 -- argument which is an /exception predicate/, a function which
286 -- selects which type of exceptions we\'re interested in. There are
287 -- some predefined exception predicates for useful subsets of
288 -- exceptions: 'ioErrors', 'arithExceptions', and so on. For example,
289 -- to catch just calls to the 'error' function, we could use
291 -- > result <- catchJust errorCalls thing_to_try handler
293 -- Any other exceptions which are not matched by the predicate
294 -- are re-raised, and may be caught by an enclosing
295 -- 'catch' or 'catchJust'.
297 :: (Exception -> Maybe b) -- ^ Predicate to select exceptions
298 -> IO a -- ^ Computation to run
299 -> (b -> IO a) -- ^ Handler
301 catchJust p a handler = catch a handler'
302 where handler' e = case p e of
306 -- | A version of 'catch' with the arguments swapped around; useful in
307 -- situations where the code for the handler is shorter. For example:
309 -- > do handle (\e -> exitWith (ExitFailure 1)) $
311 handle :: (Exception -> IO a) -> IO a -> IO a
314 -- | A version of 'catchJust' with the arguments swapped around (see
316 handleJust :: (Exception -> Maybe b) -> (b -> IO a) -> IO a -> IO a
317 handleJust p = flip (catchJust p)
319 -----------------------------------------------------------------------------
322 -- | This function maps one exception into another as proposed in the
323 -- paper \"A semantics for imprecise exceptions\".
325 -- Notice that the usage of 'unsafePerformIO' is safe here.
327 mapException :: (Exception -> Exception) -> a -> a
328 mapException f v = unsafePerformIO (catch (evaluate v)
331 -----------------------------------------------------------------------------
332 -- 'try' and variations.
334 -- | Similar to 'catch', but returns an 'Either' result which is
335 -- @('Right' a)@ if no exception was raised, or @('Left' e)@ if an
336 -- exception was raised and its value is @e@.
338 -- > try a = catch (Right `liftM` a) (return . Left)
340 -- Note: as with 'catch', it is only polite to use this variant if you intend
341 -- to re-throw the exception after performing whatever cleanup is needed.
342 -- Otherwise, 'tryJust' is generally considered to be better.
344 -- Also note that "System.IO.Error" also exports a function called
345 -- 'System.IO.Error.try' with a similar type to 'Control.OldException.try',
346 -- except that it catches only the IO and user families of exceptions
347 -- (as required by the Haskell 98 @IO@ module).
349 try :: IO a -> IO (Either Exception a)
350 try a = catch (a >>= \ v -> return (Right v)) (\e -> return (Left e))
352 -- | A variant of 'try' that takes an exception predicate to select
353 -- which exceptions are caught (c.f. 'catchJust'). If the exception
354 -- does not match the predicate, it is re-thrown.
355 tryJust :: (Exception -> Maybe b) -> IO a -> IO (Either b a)
359 Right v -> return (Right v)
360 Left e -> case p e of
362 Just b -> return (Left b)
364 -----------------------------------------------------------------------------
365 -- Dynamic exceptions
368 -- #DynamicExceptions# Because the 'Exception' datatype is not extensible, there is an
369 -- interface for throwing and catching exceptions of type 'Dynamic'
370 -- (see "Data.Dynamic") which allows exception values of any type in
371 -- the 'Typeable' class to be thrown and caught.
373 -- | Raise any value as an exception, provided it is in the
375 throwDyn :: Typeable exception => exception -> b
377 throwDyn exception = throw (UserError "" "dynamic exception")
379 throwDyn exception = throw (DynException (toDyn exception))
382 #ifdef __GLASGOW_HASKELL__
383 -- | A variant of 'throwDyn' that throws the dynamic exception to an
384 -- arbitrary thread (GHC only: c.f. 'throwTo').
385 throwDynTo :: Typeable exception => ThreadId -> exception -> IO ()
386 throwDynTo t exception = New.throwTo t (DynException (toDyn exception))
387 #endif /* __GLASGOW_HASKELL__ */
389 -- | Catch dynamic exceptions of the required type. All other
390 -- exceptions are re-thrown, including dynamic exceptions of the wrong
393 -- When using dynamic exceptions it is advisable to define a new
394 -- datatype to use for your exception type, to avoid possible clashes
395 -- with dynamic exceptions used in other libraries.
397 catchDyn :: Typeable exception => IO a -> (exception -> IO a) -> IO a
399 catchDyn m k = m -- can't catch dyn exceptions in nhc98
401 catchDyn m k = catchException m handle
402 where handle ex = case ex of
403 (DynException dyn) ->
404 case fromDynamic dyn of
405 Just exception -> k exception
410 -----------------------------------------------------------------------------
411 -- Exception Predicates
414 -- These pre-defined predicates may be used as the first argument to
415 -- 'catchJust', 'tryJust', or 'handleJust' to select certain common
416 -- classes of exceptions.
418 ioErrors :: Exception -> Maybe IOError
419 arithExceptions :: Exception -> Maybe New.ArithException
420 errorCalls :: Exception -> Maybe String
421 assertions :: Exception -> Maybe String
422 dynExceptions :: Exception -> Maybe Dynamic
423 asyncExceptions :: Exception -> Maybe New.AsyncException
424 userErrors :: Exception -> Maybe String
426 ioErrors (IOException e) = Just e
429 arithExceptions (ArithException e) = Just e
430 arithExceptions _ = Nothing
432 errorCalls (ErrorCall e) = Just e
433 errorCalls _ = Nothing
435 assertions (AssertionFailed e) = Just e
436 assertions _ = Nothing
438 dynExceptions (DynException e) = Just e
439 dynExceptions _ = Nothing
441 asyncExceptions (AsyncException e) = Just e
442 asyncExceptions _ = Nothing
444 userErrors (IOException e) | isUserError e = Just (ioeGetErrorString e)
445 userErrors _ = Nothing
447 -----------------------------------------------------------------------------
448 -- Some Useful Functions
450 -- | When you want to acquire a resource, do some work with it, and
451 -- then release the resource, it is a good idea to use 'bracket',
452 -- because 'bracket' will install the necessary exception handler to
453 -- release the resource in the event that an exception is raised
454 -- during the computation. If an exception is raised, then 'bracket' will
455 -- re-raise the exception (after performing the release).
457 -- A common example is opening a file:
460 -- > (openFile "filename" ReadMode)
462 -- > (\handle -> do { ... })
464 -- The arguments to 'bracket' are in this order so that we can partially apply
467 -- > withFile name mode = bracket (openFile name mode) hClose
471 :: IO a -- ^ computation to run first (\"acquire resource\")
472 -> (a -> IO b) -- ^ computation to run last (\"release resource\")
473 -> (a -> IO c) -- ^ computation to run in-between
474 -> IO c -- returns the value from the in-between computation
475 bracket before after thing =
480 (\e -> do { after a; throw e })
486 -- | A specialised variant of 'bracket' with just a computation to run
489 finally :: IO a -- ^ computation to run first
490 -> IO b -- ^ computation to run afterward (even if an exception
492 -> IO a -- returns the value from the first computation
497 (\e -> do { sequel; throw e })
502 -- | A variant of 'bracket' where the return value from the first computation
504 bracket_ :: IO a -> IO b -> IO c -> IO c
505 bracket_ before after thing = bracket before (const after) (const thing)
507 -- | Like bracket, but only performs the final action if there was an
508 -- exception raised by the in-between computation.
510 :: IO a -- ^ computation to run first (\"acquire resource\")
511 -> (a -> IO b) -- ^ computation to run last (\"release resource\")
512 -> (a -> IO c) -- ^ computation to run in-between
513 -> IO c -- returns the value from the in-between computation
514 bracketOnError before after thing =
519 (\e -> do { after a; throw e })
522 -- -----------------------------------------------------------------------------
523 -- Asynchronous exceptions
527 #AsynchronousExceptions# Asynchronous exceptions are so-called because they arise due to
528 external influences, and can be raised at any point during execution.
529 'StackOverflow' and 'HeapOverflow' are two examples of
530 system-generated asynchronous exceptions.
532 The primary source of asynchronous exceptions, however, is
535 > throwTo :: ThreadId -> Exception -> IO ()
537 'throwTo' (also 'throwDynTo' and 'Control.Concurrent.killThread') allows one
538 running thread to raise an arbitrary exception in another thread. The
539 exception is therefore asynchronous with respect to the target thread,
540 which could be doing anything at the time it receives the exception.
541 Great care should be taken with asynchronous exceptions; it is all too
542 easy to introduce race conditions by the over zealous use of
547 There\'s an implied 'block' around every exception handler in a call
548 to one of the 'catch' family of functions. This is because that is
549 what you want most of the time - it eliminates a common race condition
550 in starting an exception handler, because there may be no exception
551 handler on the stack to handle another exception if one arrives
552 immediately. If asynchronous exceptions are blocked on entering the
553 handler, though, we have time to install a new exception handler
554 before being interrupted. If this weren\'t the default, one would have
555 to write something like
558 > catch (unblock (...))
562 If you need to unblock asynchronous exceptions again in the exception
563 handler, just use 'unblock' as normal.
565 Note that 'try' and friends /do not/ have a similar default, because
566 there is no exception handler in this case. If you want to use 'try'
567 in an asynchronous-exception-safe way, you will need to use
573 Some operations are /interruptible/, which means that they can receive
574 asynchronous exceptions even in the scope of a 'block'. Any function
575 which may itself block is defined as interruptible; this includes
576 'Control.Concurrent.MVar.takeMVar'
577 (but not 'Control.Concurrent.MVar.tryTakeMVar'),
578 and most operations which perform
579 some I\/O with the outside world. The reason for having
580 interruptible operations is so that we can write things like
584 > catch (unblock (...))
588 if the 'Control.Concurrent.MVar.takeMVar' was not interruptible,
590 combination could lead to deadlock, because the thread itself would be
591 blocked in a state where it can\'t receive any asynchronous exceptions.
592 With 'Control.Concurrent.MVar.takeMVar' interruptible, however, we can be
593 safe in the knowledge that the thread can receive exceptions right up
594 until the point when the 'Control.Concurrent.MVar.takeMVar' succeeds.
595 Similar arguments apply for other interruptible operations like
596 'System.IO.openFile'.
599 #if !(__GLASGOW_HASKELL__ || __NHC__)
600 assert :: Bool -> a -> a
602 assert False _ = throw (AssertionFailed "")
606 #ifdef __GLASGOW_HASKELL__
607 {-# NOINLINE uncaughtExceptionHandler #-}
608 uncaughtExceptionHandler :: IORef (Exception -> IO ())
609 uncaughtExceptionHandler = unsafePerformIO (newIORef defaultHandler)
611 defaultHandler :: Exception -> IO ()
612 defaultHandler ex = do
613 (hFlush stdout) `New.catchAny` (\ _ -> return ())
615 Deadlock -> "no threads to run: infinite loop or deadlock?"
617 other -> showsPrec 0 other ""
618 withCString "%s" $ \cfmt ->
619 withCString msg $ \cmsg ->
622 -- don't use errorBelch() directly, because we cannot call varargs functions
624 foreign import ccall unsafe "HsBase.h errorBelch2"
625 errorBelch :: CString -> CString -> IO ()
627 setUncaughtExceptionHandler :: (Exception -> IO ()) -> IO ()
628 setUncaughtExceptionHandler = writeIORef uncaughtExceptionHandler
630 getUncaughtExceptionHandler :: IO (Exception -> IO ())
631 getUncaughtExceptionHandler = readIORef uncaughtExceptionHandler
634 -- ------------------------------------------------------------------------
635 -- Exception datatype and operations
637 -- |The type of exceptions. Every kind of system-generated exception
638 -- has a constructor in the 'Exception' type, and values of other
639 -- types may be injected into 'Exception' by coercing them to
640 -- 'Data.Dynamic.Dynamic' (see the section on Dynamic Exceptions:
641 -- "Control.OldException\#DynamicExceptions").
643 = ArithException New.ArithException
644 -- ^Exceptions raised by arithmetic
645 -- operations. (NOTE: GHC currently does not throw
646 -- 'ArithException's except for 'DivideByZero').
647 | ArrayException New.ArrayException
648 -- ^Exceptions raised by array-related
649 -- operations. (NOTE: GHC currently does not throw
650 -- 'ArrayException's).
651 | AssertionFailed String
652 -- ^This exception is thrown by the
653 -- 'assert' operation when the condition
654 -- fails. The 'String' argument contains the
655 -- location of the assertion in the source program.
656 | AsyncException New.AsyncException
657 -- ^Asynchronous exceptions (see section on Asynchronous Exceptions: "Control.OldException\#AsynchronousExceptions").
659 -- ^The current thread was executing a call to
660 -- 'Control.Concurrent.MVar.takeMVar' that could never return,
661 -- because there are no other references to this 'MVar'.
662 | BlockedIndefinitely
663 -- ^The current thread was waiting to retry an atomic memory transaction
664 -- that could never become possible to complete because there are no other
665 -- threads referring to any of the TVars involved.
667 -- ^The runtime detected an attempt to nest one STM transaction
668 -- inside another one, presumably due to the use of
669 -- 'unsafePeformIO' with 'atomically'.
671 -- ^There are no runnable threads, so the program is
672 -- deadlocked. The 'Deadlock' exception is
673 -- raised in the main thread only (see also: "Control.Concurrent").
674 | DynException Dynamic
675 -- ^Dynamically typed exceptions (see section on Dynamic Exceptions: "Control.OldException\#DynamicExceptions").
677 -- ^The 'ErrorCall' exception is thrown by 'error'. The 'String'
678 -- argument of 'ErrorCall' is the string passed to 'error' when it was
680 | ExitException New.ExitCode
681 -- ^The 'ExitException' exception is thrown by 'System.Exit.exitWith' (and
682 -- 'System.Exit.exitFailure'). The 'ExitCode' argument is the value passed
683 -- to 'System.Exit.exitWith'. An unhandled 'ExitException' exception in the
684 -- main thread will cause the program to be terminated with the given
686 | IOException New.IOException
687 -- ^These are the standard IO exceptions generated by
688 -- Haskell\'s @IO@ operations. See also "System.IO.Error".
689 | NoMethodError String
690 -- ^An attempt was made to invoke a class method which has
691 -- no definition in this instance, and there was no default
692 -- definition given in the class declaration. GHC issues a
693 -- warning when you compile an instance which has missing
696 -- ^The current thread is stuck in an infinite loop. This
697 -- exception may or may not be thrown when the program is
699 | PatternMatchFail String
700 -- ^A pattern matching failure. The 'String' argument should contain a
701 -- descriptive message including the function name, source file
704 -- ^An attempt was made to evaluate a field of a record
705 -- for which no value was given at construction time. The
706 -- 'String' argument gives the location of the
707 -- record construction in the source program.
709 -- ^A field selection was attempted on a constructor that
710 -- doesn\'t have the requested field. This can happen with
711 -- multi-constructor records when one or more fields are
712 -- missing from some of the constructors. The
713 -- 'String' argument gives the location of the
714 -- record selection in the source program.
716 -- ^An attempt was made to update a field in a record,
717 -- where the record doesn\'t have the requested field. This can
718 -- only occur with multi-constructor records, when one or more
719 -- fields are missing from some of the constructors. The
720 -- 'String' argument gives the location of the
721 -- record update in the source program.
722 INSTANCE_TYPEABLE0(Exception,exceptionTc,"Exception")
724 nonTermination :: SomeException
725 nonTermination = New.toException NonTermination
727 -- For now at least, make the monolithic Exception type an instance of
728 -- the Exception class
729 instance New.Exception Exception
731 instance Show Exception where
732 showsPrec _ (IOException err) = shows err
733 showsPrec _ (ArithException err) = shows err
734 showsPrec _ (ArrayException err) = shows err
735 showsPrec _ (ErrorCall err) = showString err
736 showsPrec _ (ExitException err) = showString "exit: " . shows err
737 showsPrec _ (NoMethodError err) = showString err
738 showsPrec _ (PatternMatchFail err) = showString err
739 showsPrec _ (RecSelError err) = showString err
740 showsPrec _ (RecConError err) = showString err
741 showsPrec _ (RecUpdError err) = showString err
742 showsPrec _ (AssertionFailed err) = showString err
743 showsPrec _ (DynException err) = showString "exception :: " . showsTypeRep (dynTypeRep err)
744 showsPrec _ (AsyncException e) = shows e
745 showsPrec p BlockedOnDeadMVar = showsPrec p New.BlockedOnDeadMVar
746 showsPrec p BlockedIndefinitely = showsPrec p New.BlockedIndefinitely
747 showsPrec p NestedAtomically = showsPrec p New.NestedAtomically
748 showsPrec p NonTermination = showsPrec p New.NonTermination
749 showsPrec p Deadlock = showsPrec p New.Deadlock
751 instance Eq Exception where
752 IOException e1 == IOException e2 = e1 == e2
753 ArithException e1 == ArithException e2 = e1 == e2
754 ArrayException e1 == ArrayException e2 = e1 == e2
755 ErrorCall e1 == ErrorCall e2 = e1 == e2
756 ExitException e1 == ExitException e2 = e1 == e2
757 NoMethodError e1 == NoMethodError e2 = e1 == e2
758 PatternMatchFail e1 == PatternMatchFail e2 = e1 == e2
759 RecSelError e1 == RecSelError e2 = e1 == e2
760 RecConError e1 == RecConError e2 = e1 == e2
761 RecUpdError e1 == RecUpdError e2 = e1 == e2
762 AssertionFailed e1 == AssertionFailed e2 = e1 == e2
763 DynException _ == DynException _ = False -- incomparable
764 AsyncException e1 == AsyncException e2 = e1 == e2
765 BlockedOnDeadMVar == BlockedOnDeadMVar = True
766 NonTermination == NonTermination = True
767 NestedAtomically == NestedAtomically = True
768 Deadlock == Deadlock = True