Control.Monad.Class.MonadThrow

Documentation

class Monad m => MonadThrow m where

Throwing exceptions, and resource handling in the presence of exceptions.

Does not include the ability to respond to exceptions.

Minimal complete definition

throwIO

Methods

throwIO :: Exception e => e -> m a

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

default bracket :: MonadCatch m => m a -> (a -> m b) -> (a -> m c) -> m c

bracket_ :: m a -> m b -> m c -> m c

finally :: m a -> m b -> m a

Instances

MonadThrow STM

Defined in Control.Monad.Class.MonadThrow

Methods

throwIO :: Exception e => e -> STM a

bracket :: STM a -> (a -> STM b) -> (a -> STM c) -> STM c

bracket_ :: STM a -> STM b -> STM c -> STM c

finally :: STM a -> STM b -> STM a

MonadThrow IO

Defined in Control.Monad.Class.MonadThrow

Methods

throwIO :: Exception e => e -> IO a

bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

bracket_ :: IO a -> IO b -> IO c -> IO c

finally :: IO a -> IO b -> IO a

MonadThrow m => MonadThrow (ReaderT r m)

Defined in Control.Monad.Class.MonadThrow

Methods

throwIO :: Exception e => e -> ReaderT r m a

bracket :: ReaderT r m a -> (a -> ReaderT r m b) -> (a -> ReaderT r m c) -> ReaderT r m c

bracket_ :: ReaderT r m a -> ReaderT r m b -> ReaderT r m c -> ReaderT r m c

finally :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

class MonadThrow m => MonadCatch m where

Catching exceptions.

Covers standard utilities to respond to exceptions.

Minimal complete definition

catch

Methods

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

catchJust :: Exception e => (e -> Maybe b) -> m a -> (b -> m a) -> m a

try :: Exception e => m a -> m (Either e a)

tryJust :: Exception e => (e -> Maybe b) -> m a -> m (Either b a)

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

handleJust :: Exception e => (e -> Maybe b) -> (b -> m a) -> m a -> m a

onException :: m a -> m b -> m a

bracketOnError :: m a -> (a -> m b) -> (a -> m c) -> m c

generalBracket :: m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)

General form of bracket

See http://hackage.haskell.org/package/exceptions-0.10.0/docs/Control-Monad-Catch.html#v:generalBracket for discussion and motivation.

default generalBracket :: MonadMask m => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)

Instances

MonadCatch STM

Defined in Control.Monad.Class.MonadThrow

Methods

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

catchJust :: Exception e => (e -> Maybe b) -> STM a -> (b -> STM a) -> STM a

try :: Exception e => STM a -> STM (Either e a)

tryJust :: Exception e => (e -> Maybe b) -> STM a -> STM (Either b a)

handle :: Exception e => (e -> STM a) -> STM a -> STM a

handleJust :: Exception e => (e -> Maybe b) -> (b -> STM a) -> STM a -> STM a

onException :: STM a -> STM b -> STM a

bracketOnError :: STM a -> (a -> STM b) -> (a -> STM c) -> STM c

generalBracket :: STM a -> (a -> ExitCase b -> STM c) -> (a -> STM b) -> STM (b, c)

MonadCatch IO

Defined in Control.Monad.Class.MonadThrow

Methods

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

catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a

try :: Exception e => IO a -> IO (Either e a)

tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)

handle :: Exception e => (e -> IO a) -> IO a -> IO a

handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a

onException :: IO a -> IO b -> IO a

bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c

generalBracket :: IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c)

MonadCatch m => MonadCatch (ReaderT r m)

Defined in Control.Monad.Class.MonadThrow

Methods

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

catchJust :: Exception e => (e -> Maybe b) -> ReaderT r m a -> (b -> ReaderT r m a) -> ReaderT r m a

try :: Exception e => ReaderT r m a -> ReaderT r m (Either e a)

tryJust :: Exception e => (e -> Maybe b) -> ReaderT r m a -> ReaderT r m (Either b a)

handle :: Exception e => (e -> ReaderT r m a) -> ReaderT r m a -> ReaderT r m a

handleJust :: Exception e => (e -> Maybe b) -> (b -> ReaderT r m a) -> ReaderT r m a -> ReaderT r m a

onException :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

bracketOnError :: ReaderT r m a -> (a -> ReaderT r m b) -> (a -> ReaderT r m c) -> ReaderT r m c

generalBracket :: ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c)

class MonadCatch m => MonadMask m where

Support for safely working in the presence of asynchronous exceptions.

This is typically not needed directly as the utilities in MonadThrow and MonadCatch cover most use cases.

Minimal complete definition

mask, uninterruptibleMask

Methods

mask :: ((forall a. m a -> m a) -> m b) -> m b

uninterruptibleMask :: ((forall a. m a -> m a) -> m b) -> m b

mask_ :: m a -> m a

uninterruptibleMask_ :: m a -> m a

Instances

MonadMask IO

Defined in Control.Monad.Class.MonadThrow

Methods

mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b

mask_ :: IO a -> IO a

uninterruptibleMask_ :: IO a -> IO a

MonadMask m => MonadMask (ReaderT r m)

Defined in Control.Monad.Class.MonadThrow

Methods

mask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

uninterruptibleMask :: ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b

mask_ :: ReaderT r m a -> ReaderT r m a

uninterruptibleMask_ :: ReaderT r m a -> ReaderT r m a

class MonadMask m => MonadMaskingState m where

Minimal complete definition

getMaskingState, interruptible

Methods

getMaskingState :: m MaskingState

interruptible :: m a -> m a

allowInterrupt :: m ()

Instances

MonadMaskingState IO

Defined in Control.Monad.Class.MonadThrow

Methods

getMaskingState :: IO MaskingState

interruptible :: IO a -> IO a

allowInterrupt :: IO ()

class MonadThrow m => MonadEvaluate m where

Monads which can evaluate.

Methods

evaluate :: a -> m a

Instances

MonadEvaluate IO

Defined in Control.Monad.Class.MonadThrow

Methods

evaluate :: a -> IO a

MonadEvaluate m => MonadEvaluate (ReaderT r m)

Defined in Control.Monad.Class.MonadThrow

Methods

evaluate :: a -> ReaderT r m a

data MaskingState

Describes the behaviour of a thread when an asynchronous exception is received.

Constructors

Unmasked

asynchronous exceptions are unmasked (the normal state)

MaskedInterruptible

the state during mask: asynchronous exceptions are masked, but blocking operations may still be interrupted

MaskedUninterruptible

the state during uninterruptibleMask: asynchronous exceptions are masked, and blocking operations may not be interrupted

Instances

Show MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

showsPrec :: Int -> MaskingState -> ShowS

show :: MaskingState -> String

showList :: [MaskingState] -> ShowS

Eq MaskingState

Since: base-4.3.0.0

Defined in GHC.IO

Methods

(==) :: MaskingState -> MaskingState -> Bool

(/=) :: MaskingState -> MaskingState -> Bool

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

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

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

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

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 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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException

fromException :: SomeException -> Maybe e

displayException :: e -> String

Render this exception value in a human-friendly manner.

Default implementation: show.

Since: base-4.8.0.0

Instances

Exception AsyncCancelled

Defined in Control.Concurrent.Async

Methods

toException :: AsyncCancelled -> SomeException

fromException :: SomeException -> Maybe AsyncCancelled

displayException :: AsyncCancelled -> String

Exception ExceptionInLinkedThread

Defined in Control.Concurrent.Async

Methods

toException :: ExceptionInLinkedThread -> SomeException

fromException :: SomeException -> Maybe ExceptionInLinkedThread

displayException :: ExceptionInLinkedThread -> String

Exception NestedAtomically

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NestedAtomically -> SomeException

fromException :: SomeException -> Maybe NestedAtomically

displayException :: NestedAtomically -> String

Exception NoMethodError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NoMethodError -> SomeException

fromException :: SomeException -> Maybe NoMethodError

displayException :: NoMethodError -> String

Exception NonTermination

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: NonTermination -> SomeException

fromException :: SomeException -> Maybe NonTermination

displayException :: NonTermination -> String

Exception PatternMatchFail

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: PatternMatchFail -> SomeException

fromException :: SomeException -> Maybe PatternMatchFail

displayException :: PatternMatchFail -> String

Exception RecConError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecConError -> SomeException

fromException :: SomeException -> Maybe RecConError

displayException :: RecConError -> String

Exception RecSelError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecSelError -> SomeException

fromException :: SomeException -> Maybe RecSelError

displayException :: RecSelError -> String

Exception RecUpdError

Since: base-4.0

Defined in Control.Exception.Base

Methods

toException :: RecUpdError -> SomeException

fromException :: SomeException -> Maybe RecUpdError

displayException :: RecUpdError -> String

Exception TypeError

Since: base-4.9.0.0

Defined in Control.Exception.Base

Methods

toException :: TypeError -> SomeException

fromException :: SomeException -> Maybe TypeError

displayException :: TypeError -> String

Exception Void

Since: base-4.8.0.0

Defined in Data.Void

Methods

toException :: Void -> SomeException

fromException :: SomeException -> Maybe Void

displayException :: Void -> String

Exception ErrorCall

Since: base-4.0.0.0

Defined in GHC.Exception

Methods

toException :: ErrorCall -> SomeException

fromException :: SomeException -> Maybe ErrorCall

displayException :: ErrorCall -> String

Exception ArithException

Since: base-4.0.0.0

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException

fromException :: SomeException -> Maybe ArithException

displayException :: ArithException -> String

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Exception AllocationLimitExceeded

Since: base-4.8.0.0

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException

fromException :: SomeException -> Maybe AllocationLimitExceeded

displayException :: AllocationLimitExceeded -> String

Exception ArrayException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException

fromException :: SomeException -> Maybe ArrayException

displayException :: ArrayException -> String

Exception AssertionFailed

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException

fromException :: SomeException -> Maybe AssertionFailed

displayException :: AssertionFailed -> String

Exception AsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException

fromException :: SomeException -> Maybe AsyncException

displayException :: AsyncException -> String

Exception BlockedIndefinitelyOnMVar

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar

displayException :: BlockedIndefinitelyOnMVar -> String

Exception BlockedIndefinitelyOnSTM

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM

displayException :: BlockedIndefinitelyOnSTM -> String

Exception CompactionFailed

Since: base-4.10.0.0

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException

fromException :: SomeException -> Maybe CompactionFailed

displayException :: CompactionFailed -> String

Exception Deadlock

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException

fromException :: SomeException -> Maybe Deadlock

displayException :: Deadlock -> String

Exception ExitCode

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException

fromException :: SomeException -> Maybe ExitCode

displayException :: ExitCode -> String

Exception FixIOException

Since: base-4.11.0.0

Defined in GHC.IO.Exception

Methods

toException :: FixIOException -> SomeException

fromException :: SomeException -> Maybe FixIOException

displayException :: FixIOException -> String

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

Exception SomeAsyncException

Since: base-4.7.0.0

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException

fromException :: SomeException -> Maybe SomeAsyncException

displayException :: SomeAsyncException -> String

Exception Timeout

Since: base-4.7.0.0

Defined in System.Timeout

Methods

toException :: Timeout -> SomeException

fromException :: SomeException -> Maybe Timeout

displayException :: Timeout -> String

Exception ExceptionInLinkedThread

Defined in Control.Monad.Class.MonadAsync

Methods

toException :: ExceptionInLinkedThread -> SomeException

fromException :: SomeException -> Maybe ExceptionInLinkedThread

displayException :: ExceptionInLinkedThread -> String

data SomeException

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.

Instances

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Show SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

data ExitCase a

Used in generalBracket

See exceptions package for discussion and motivation.

Constructors

ExitCaseSuccess a

ExitCaseException SomeException

ExitCaseAbort

Instances

Functor ExitCase

Defined in Control.Monad.Class.MonadThrow

Methods

fmap :: (a -> b) -> ExitCase a -> ExitCase b

(<$) :: a -> ExitCase b -> ExitCase a

Show a => Show (ExitCase a)

Defined in Control.Monad.Class.MonadThrow

Methods

showsPrec :: Int -> ExitCase a -> ShowS

show :: ExitCase a -> String

showList :: [ExitCase a] -> ShowS

data Handler m a

The default handler type for catches, whcih is a generalisation of Handler.

Constructors

forall e.Exception e => Handler (e -> m a)

Instances

Functor m => Functor (Handler m)

Defined in Control.Monad.Class.MonadThrow

Methods

fmap :: (a -> b) -> Handler m a -> Handler m b

(<$) :: a -> Handler m b -> Handler m a

catches :: forall m a. MonadCatch m => m a -> [Handler m a] -> m a

Like catches but for MonadCatch rather than only IO.