System.Console.Haskeline.MonadException

haskeline-0.6.4.0: A command-line interface for user input, written in Haskell.

System.Console.Haskeline.MonadException

Description

This module redefines some of the functions in Control.Exception.Extensible to work for more general monads than only `IO`.

Synopsis

- class MonadIO m => MonadException m where
  - catch :: Exception e => m a -> (e -> m a) -> m a
  - block :: m a -> m a
  - unblock :: m a -> m a
- handle :: (MonadException m, Exception e) => (e -> m a) -> m a -> m a
- finally :: MonadException m => m a -> m b -> m a
- throwIO :: (MonadIO m, Exception e) => e -> m a
- throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()
- bracket :: MonadException m => m a -> (a -> m b) -> (a -> m c) -> m c
- throwDynIO :: (Exception exception, MonadIO m) => exception -> m a
- handleDyn :: (Exception exception, MonadException m) => (exception -> m a) -> m a -> m a
- class (Typeable e, Show e) => Exception e
- data SomeException where
  - SomeException :: Exception e => e -> SomeException
- data IOException

# Documentation

class MonadIO m => MonadException m where

Methods

catch :: Exception e => m a -> (e -> m a) -> m a

block :: m a -> m a

unblock :: m a -> m a

Instances

MonadException IO |
MonadException m => MonadException (MaybeT m) |
MonadException m => MonadException (Draw m) |
MonadException m => MonadException (DumbTerm m) |
MonadException m => MonadException (InputT m) |
MonadException m => MonadException (ReaderT r m) |
MonadException m => MonadException (StateT s m) |
MonadException m => MonadException (StateT s m) |

handle :: (MonadException m, Exception e) => (e -> m a) -> m a -> m a

finally :: MonadException m => m a -> m b -> m a

throwIO :: (MonadIO m, Exception e) => e -> m a

throwTo :: (MonadIO m, Exception e) => ThreadId -> e -> m ()

bracket :: MonadException m => m a -> (a -> m b) -> (a -> m c) -> m c

throwDynIO :: (Exception exception, MonadIO m) => exception -> m a

handleDyn :: (Exception exception, MonadException m) => (exception -> m a) -> m a -> m a

class (Typeable e, Show e) => Exception e

Any type that you wish to throw or catch as an exception must be an instance of the `Exception` class. The simplest case is a new exception type directly below the root:

     data MyException = ThisException | ThatException
         deriving (Show, Typeable)

     instance Exception MyException

The default method definitions in the `Exception` class do what we need in this case. You can now throw and catch `ThisException` and `ThatException` as exceptions:

    *Main> throw ThisException catch e -> putStrLn ("Caught " ++ show (e :: MyException))
    Caught ThisException

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

     ---------------------------------------------------------------------
     -- Make the root exception type for all the exceptions in a compiler

     data SomeCompilerException = forall e . Exception e => SomeCompilerException e
         deriving Typeable

     instance Show SomeCompilerException where
         show (SomeCompilerException e) = show e

     instance Exception SomeCompilerException

     compilerExceptionToException :: Exception e => e -> SomeException
     compilerExceptionToException = toException . SomeCompilerException

     compilerExceptionFromException :: Exception e => SomeException -> Maybe e
     compilerExceptionFromException x = do
         SomeCompilerException a <- fromException x
         cast a

     ---------------------------------------------------------------------
     -- Make a subhierarchy for exceptions in the frontend of the compiler

     data SomeFrontendException = forall e . Exception e => SomeFrontendException e
         deriving Typeable

     instance Show SomeFrontendException where
         show (SomeFrontendException e) = show e

     instance Exception SomeFrontendException where
         toException = compilerExceptionToException
         fromException = compilerExceptionFromException

     frontendExceptionToException :: Exception e => e -> SomeException
     frontendExceptionToException = toException . SomeFrontendException

     frontendExceptionFromException :: Exception e => SomeException -> Maybe e
     frontendExceptionFromException x = do
         SomeFrontendException a <- fromException x
         cast a

     ---------------------------------------------------------------------
     -- Make an exception type for a particular frontend compiler exception

     data MismatchedParentheses = MismatchedParentheses
         deriving (Typeable, Show)

     instance Exception MismatchedParentheses where
         toException   = frontendExceptionToException
         fromException = frontendExceptionFromException

We can now catch a `MismatchedParentheses` exception as `MismatchedParentheses`, `SomeFrontendException` or `SomeCompilerException`, but not other types, e.g. `IOException`:

    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
    Caught MismatchedParentheses
    *Main> throw MismatchedParentheses catch e -> putStrLn ("Caught " ++ show (e :: IOException))
    *** Exception: MismatchedParentheses

Instances

Exception PatternMatchFail |
Exception RecSelError |
Exception RecConError |
Exception RecUpdError |
Exception NoMethodError |
Exception NonTermination |
Exception NestedAtomically |
Exception BlockedIndefinitelyOnMVar |
Exception BlockedIndefinitelyOnSTM |
Exception Deadlock |
Exception AssertionFailed |
Exception AsyncException |
Exception ArrayException |
Exception ExitCode |
Exception Dynamic |
Exception IOException |
Exception SomeException |
Exception ErrorCall |
Exception ArithException |
Exception SetupTermError |
Exception Interrupt |

data SomeException where

The `SomeException` type is the root of the exception type hierarchy. When an exception of type `e` is thrown, behind the scenes it is encapsulated in a `SomeException`.

Constructors

SomeException :: Exception e => e -> SomeException |

Instances

Show SomeException |
Typeable SomeException |
Exception SomeException |

data IOException

Exceptions that occur in the `IO` monad. An `IOException` records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Instances

Eq IOException |
Show IOException |
Typeable IOException |
Exception IOException |
Error IOException |