Safe Haskell	Trustworthy
Language	Haskell2010

Pipes.Safe

Contents

SafeT
MonadSafe
Utilities
Internals
Re-exports
Orphan instances

Description

This module provides an orphan MonadMask instance for Proxy of the form:

instance (MonadMask m, MonadIO m) => MonadMask (Proxy a' a b' b m) where

Which is needed to implement the instance for MonadSafe for Proxy.

This module also provides generalized versions of some MonadCatch operations so that you can also protect against premature termination of connected components. For example, if you protect a readFile computation using bracket from this module:

-- readFile.hs
import Pipes
import qualified Pipes.Prelude as P
import Pipes.Safe
import qualified System.IO as IO
import Prelude hiding (readFile)

readFile :: FilePath -> Producer' String (SafeT IO) ()
readFile file = bracket
    (do h <- IO.openFile file IO.ReadMode
        putStrLn $ "{" ++ file ++ " open}"
        return h )
    (\h -> do
        IO.hClose h
        putStrLn $ "{" ++ file ++ " closed}" )
    P.fromHandle

... then this generalized bracket will guard against both exceptions and premature termination of other pipes:

>>> runSafeT $ runEffect $ readFile "readFile.hs" >-> P.take 4 >-> P.stdoutLn
{readFile.hs open}
-- readFile.hs
import Pipes
import qualified Pipes.Prelude as P
import Pipes.Safe
{readFile.hs closed}

Note that the MonadCatch instance for Proxy provides weaker versions of mask and uninterruptibleMask that do not completely prevent asynchronous exceptions. Instead, they provide a weaker guarantee that asynchronous exceptions will only occur during awaits or yields and nowhere else. For example, if you write:

mask_ $ do
    x <- await
    lift $ print x
    lift $ print x

... then you may receive an asynchronous exception during the await, but you will not receive an asynchronous exception during or in between the two print statements. This weaker guarantee suffices to provide asynchronous exception safety.

Synopsis

newtype SafeT (m :: Type -> Type) r = SafeT (ReaderT (Env m) m r)
runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r
runSafeP :: forall (m :: Type -> Type) r. (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r
data ReleaseKey
class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe (m :: Type -> Type) where
- type Base (m :: Type -> Type) :: Type -> Type
- liftBase :: Base m r -> m r
- register :: Base m () -> m ReleaseKey
- release :: ReleaseKey -> m ()
onException :: MonadSafe m => m a -> Base m b -> m a
tryP :: forall (m :: Type -> Type) e a' a b' b r. (MonadSafe m, Exception e) => Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)
catchP :: forall (m :: Type -> Type) e a' a b' b r. (MonadSafe m, Exception e) => Proxy a' a b' b m r -> (e -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
finally :: MonadSafe m => m a -> Base m b -> m a
bracket :: MonadSafe m => Base m a -> (a -> Base m b) -> (a -> m c) -> m c
bracket_ :: MonadSafe m => Base m a -> Base m b -> m c -> m c
bracketOnError :: MonadSafe m => Base m a -> (a -> Base m b) -> (a -> m c) -> m c
data Env (m :: Type -> Type)
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- backtraceDesired :: e -> Bool
data SomeException
class MonadThrow m => MonadCatch (m :: Type -> Type) where
- catch :: (HasCallStack, Exception e) => m a -> (e -> m a) -> m a
class Monad m => MonadThrow (m :: Type -> Type) where
- throwM :: (HasCallStack, Exception e) => e -> m a
class MonadCatch m => MonadMask (m :: Type -> Type) where
- mask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
- uninterruptibleMask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
- generalBracket :: HasCallStack => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
data ExitCase a
- = ExitCaseSuccess a
- | ExitCaseException SomeException
- | ExitCaseAbort
mask_ :: (HasCallStack, MonadMask m) => m a -> m a
uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a
catchAll :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a
catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a
catchJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
catchIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a
data Handler (m :: Type -> Type) a = Exception e => Handler (e -> m a)
catches :: (HasCallStack, Foldable f, MonadCatch m) => m a -> f (Handler m a) -> m a
handle :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a
handleAll :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a
handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a
handleJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
handleIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a
tryJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- backtraceDesired :: e -> Bool
data SomeException = (Exception e, HasExceptionContext) => SomeException e

SafeT

newtype SafeT (m :: Type -> Type) r Source #

SafeT is a monad transformer that extends the base monad with the ability to register and release finalizers.

All unreleased finalizers are called at the end of the SafeT block, even in the event of exceptions.

Constructors

SafeT (ReaderT (Env m) m r)

Constructor exported in case it's necessary for integrating SafeT with other libraries. For example, implementing mtl-like MonadSomething instances will often require access to the SafeT constructor.

Warning: Using the Env outside the corresponding SafeT scope will result in undefined behavior.

Instances

Instances details

MonadTrans SafeT Source #

Instance details

Defined in Pipes.Safe

Methods

lift :: Monad m => m a -> SafeT m a #

MonadBaseControl b m => MonadBaseControl b (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

liftBaseWith :: (RunInBase (SafeT m) b -> b a) -> SafeT m a Source #

restoreM :: StM (SafeT m) a -> SafeT m a Source #

MonadError e m => MonadError e (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

throwError :: e -> SafeT m a

catchError :: SafeT m a -> (e -> SafeT m a) -> SafeT m a

MonadState s m => MonadState s (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

get :: SafeT m s

put :: s -> SafeT m ()

state :: (s -> (a, s)) -> SafeT m a

MonadWriter w m => MonadWriter w (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

writer :: (a, w) -> SafeT m a

tell :: w -> SafeT m ()

listen :: SafeT m a -> SafeT m (a, w)

pass :: SafeT m (a, w -> w) -> SafeT m a

MonadBase b m => MonadBase b (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

liftBase :: b α -> SafeT m α Source #

MonadIO m => MonadIO (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

liftIO :: IO a -> SafeT m a #

MonadCatch m => MonadCatch (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

catch :: (HasCallStack, Exception e) => SafeT m a -> (e -> SafeT m a) -> SafeT m a #

MonadMask m => MonadMask (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

mask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b #

uninterruptibleMask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b #

generalBracket :: HasCallStack => SafeT m a -> (a -> ExitCase b -> SafeT m c) -> (a -> SafeT m b) -> SafeT m (b, c) #

MonadThrow m => MonadThrow (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

throwM :: (HasCallStack, Exception e) => e -> SafeT m a #

Alternative m => Alternative (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

empty :: SafeT m a

(<|>) :: SafeT m a -> SafeT m a -> SafeT m a

some :: SafeT m a -> SafeT m [a]

many :: SafeT m a -> SafeT m [a]

Applicative m => Applicative (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

pure :: a -> SafeT m a

(<*>) :: SafeT m (a -> b) -> SafeT m a -> SafeT m b

liftA2 :: (a -> b -> c) -> SafeT m a -> SafeT m b -> SafeT m c

(*>) :: SafeT m a -> SafeT m b -> SafeT m b

(<*) :: SafeT m a -> SafeT m b -> SafeT m a

Functor m => Functor (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

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

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

Monad m => Monad (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

(>>=) :: SafeT m a -> (a -> SafeT m b) -> SafeT m b

(>>) :: SafeT m a -> SafeT m b -> SafeT m b

return :: a -> SafeT m a

MonadPlus m => MonadPlus (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

mzero :: SafeT m a #

mplus :: SafeT m a -> SafeT m a -> SafeT m a #

MonadFail m => MonadFail (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

fail :: String -> SafeT m a

MonadFix m => MonadFix (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

mfix :: (a -> SafeT m a) -> SafeT m a

MonadCont m => MonadCont (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Methods

callCC :: ((a -> SafeT m b) -> SafeT m a) -> SafeT m a

(MonadIO m, MonadCatch m, MonadMask m) => MonadSafe (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (SafeT m)
Instance details Defined in Pipes.Safe type Base (SafeT m) = m

Methods

liftBase :: Base (SafeT m) r -> SafeT m r Source #

register :: Base (SafeT m) () -> SafeT m ReleaseKey Source #

release :: ReleaseKey -> SafeT m () Source #

PrimMonad m => PrimMonad (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type PrimState (SafeT m)
Instance details Defined in Pipes.Safe type PrimState (SafeT m) = PrimState m

Methods

primitive :: (State# (PrimState (SafeT m)) -> (# State# (PrimState (SafeT m)), a #)) -> SafeT m a Source #

type Base (SafeT m) Source #

Instance details

Defined in Pipes.Safe

type Base (SafeT m) = m

type PrimState (SafeT m) Source #

Instance details

Defined in Pipes.Safe

type PrimState (SafeT m) = PrimState m

type StM (SafeT m) a Source #

Instance details

Defined in Pipes.Safe

type StM (SafeT m) a = StM m a

runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r Source #

Run the SafeT monad transformer, executing all unreleased finalizers at the end of the computation

runSafeP :: forall (m :: Type -> Type) r. (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r Source #

Run SafeT in the base monad, executing all unreleased finalizers at the end of the computation

Use runSafeP to safely flush all unreleased finalizers and ensure prompt finalization without exiting the Proxy monad.

MonadSafe

data ReleaseKey Source #

Token used to release a previously registered finalizer

class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe (m :: Type -> Type) where Source #

MonadSafe lets you register and release finalizers that execute in a Base monad

Associated Types

type Base (m :: Type -> Type) :: Type -> Type Source #

The monad used to run resource management actions, corresponding to the monad directly beneath SafeT

Methods

liftBase :: Base m r -> m r Source #

Lift an action from the Base monad

register :: Base m () -> m ReleaseKey Source #

register a finalizer, ensuring that the finalizer gets called if the finalizer is not released before the end of the surrounding SafeT block.

release :: ReleaseKey -> m () Source #

release a registered finalizer

You can safely call release more than once on the same ReleaseKey. Every release after the first one does nothing.

Instances

Instances details

MonadSafe m => MonadSafe (CatchT m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (CatchT m)
Instance details Defined in Pipes.Safe type Base (CatchT m) = Base m

Methods

liftBase :: Base (CatchT m) r -> CatchT m r Source #

register :: Base (CatchT m) () -> CatchT m ReleaseKey Source #

release :: ReleaseKey -> CatchT m () Source #

(MonadIO m, MonadCatch m, MonadMask m) => MonadSafe (SafeT m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (SafeT m)
Instance details Defined in Pipes.Safe type Base (SafeT m) = m

Methods

liftBase :: Base (SafeT m) r -> SafeT m r Source #

register :: Base (SafeT m) () -> SafeT m ReleaseKey Source #

release :: ReleaseKey -> SafeT m () Source #

MonadSafe m => MonadSafe (IdentityT m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (IdentityT m)
Instance details Defined in Pipes.Safe type Base (IdentityT m) = Base m

Methods

liftBase :: Base (IdentityT m) r -> IdentityT m r Source #

register :: Base (IdentityT m) () -> IdentityT m ReleaseKey Source #

release :: ReleaseKey -> IdentityT m () Source #

MonadSafe m => MonadSafe (ReaderT i m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (ReaderT i m)
Instance details Defined in Pipes.Safe type Base (ReaderT i m) = Base m

Methods

liftBase :: Base (ReaderT i m) r -> ReaderT i m r Source #

register :: Base (ReaderT i m) () -> ReaderT i m ReleaseKey Source #

release :: ReleaseKey -> ReaderT i m () Source #

MonadSafe m => MonadSafe (StateT s m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (StateT s m)
Instance details Defined in Pipes.Safe type Base (StateT s m) = Base m

Methods

liftBase :: Base (StateT s m) r -> StateT s m r Source #

register :: Base (StateT s m) () -> StateT s m ReleaseKey Source #

release :: ReleaseKey -> StateT s m () Source #

MonadSafe m => MonadSafe (StateT s m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (StateT s m)
Instance details Defined in Pipes.Safe type Base (StateT s m) = Base m

Methods

liftBase :: Base (StateT s m) r -> StateT s m r Source #

register :: Base (StateT s m) () -> StateT s m ReleaseKey Source #

release :: ReleaseKey -> StateT s m () Source #

(MonadSafe m, Monoid w) => MonadSafe (WriterT w m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (WriterT w m)
Instance details Defined in Pipes.Safe type Base (WriterT w m) = Base m

Methods

liftBase :: Base (WriterT w m) r -> WriterT w m r Source #

register :: Base (WriterT w m) () -> WriterT w m ReleaseKey Source #

release :: ReleaseKey -> WriterT w m () Source #

(MonadSafe m, Monoid w) => MonadSafe (WriterT w m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (WriterT w m)
Instance details Defined in Pipes.Safe type Base (WriterT w m) = Base m

Methods

liftBase :: Base (WriterT w m) r -> WriterT w m r Source #

register :: Base (WriterT w m) () -> WriterT w m ReleaseKey Source #

release :: ReleaseKey -> WriterT w m () Source #

(MonadSafe m, Monoid w) => MonadSafe (RWST i w s m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (RWST i w s m)
Instance details Defined in Pipes.Safe type Base (RWST i w s m) = Base m

Methods

liftBase :: Base (RWST i w s m) r -> RWST i w s m r Source #

register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey Source #

release :: ReleaseKey -> RWST i w s m () Source #

(MonadSafe m, Monoid w) => MonadSafe (RWST i w s m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (RWST i w s m)
Instance details Defined in Pipes.Safe type Base (RWST i w s m) = Base m

Methods

liftBase :: Base (RWST i w s m) r -> RWST i w s m r Source #

register :: Base (RWST i w s m) () -> RWST i w s m ReleaseKey Source #

release :: ReleaseKey -> RWST i w s m () Source #

MonadSafe m => MonadSafe (Proxy a' a b' b m) Source #

Instance details

Defined in Pipes.Safe

Associated Types

type Base (Proxy a' a b' b m)
Instance details Defined in Pipes.Safe type Base (Proxy a' a b' b m) = Base m

Methods

liftBase :: Base (Proxy a' a b' b m) r -> Proxy a' a b' b m r Source #

register :: Base (Proxy a' a b' b m) () -> Proxy a' a b' b m ReleaseKey Source #

release :: ReleaseKey -> Proxy a' a b' b m () Source #

Utilities

These utilities let you supply a finalizer that runs in the Base monad (i.e. the monad directly beneath SafeT). If you don't need to use the full power of the Base monad and you only need to use to use IO, then just wrap the finalizer in liftIO, like this:

myAction `finally` (liftIO myFinalizer)

This will lead to a simple inferred type with a single MonadSafe constraint:

(MonadSafe m) => ...

For examples of this, see the utilities in Pipes.Safe.Prelude.

If you omit the liftIO, the compiler will infer the following constraint instead:

(MonadSafe m, Base m ~ IO) => ...

This means that this function would require IO directly beneath the SafeT monad transformer, which might not be what you want.

onException :: MonadSafe m => m a -> Base m b -> m a Source #

Analogous to onException from Control.Monad.Catch, except this also protects against premature termination

(`onException` io) is a monad morphism.

tryP :: forall (m :: Type -> Type) e a' a b' b r. (MonadSafe m, Exception e) => Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r) Source #

Transform a Proxy into one that catches any exceptions caused by its effects, and returns the resulting exception.

catchP :: forall (m :: Type -> Type) e a' a b' b r. (MonadSafe m, Exception e) => Proxy a' a b' b m r -> (e -> Proxy a' a b' b m r) -> Proxy a' a b' b m r Source #

Allows direct handling of exceptions raised by the effects in a Proxy.

finally :: MonadSafe m => m a -> Base m b -> m a Source #

Analogous to finally from Control.Monad.Catch, except this also protects against premature termination

bracket :: MonadSafe m => Base m a -> (a -> Base m b) -> (a -> m c) -> m c Source #

Analogous to bracket from Control.Monad.Catch, except this also protects against premature termination

bracket_ :: MonadSafe m => Base m a -> Base m b -> m c -> m c Source #

Analogous to bracket_ from Control.Monad.Catch, except this also protects against premature termination

bracketOnError :: MonadSafe m => Base m a -> (a -> Base m b) -> (a -> m c) -> m c Source #

Analogous to bracketOnError from Control.Monad.Catch, except this also protects against premature termination

Internals

data Env (m :: Type -> Type) Source #

Internal SafeT read-write environment. Exported only so that it can be passed around unmodified by users of the SafeT constructor.

Warning: Using the Env outside the corresponding SafeT scope will result in undefined behavior.

Re-exports

Control.Monad.Catch re-exports all functions except for the ones that conflict with the generalized versions provided here (i.e. bracket, finally, etc.).

Control.Exception re-exports Exception and SomeException.

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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

backtraceDesired :: e -> Bool #

Instances

Instances details

Exception Timeout
Instance details Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String # backtraceDesired :: Timeout -> Bool #
Exception Void
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # backtraceDesired :: Void -> Bool #
Exception ArithException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String # backtraceDesired :: ArithException -> Bool #
Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Exception AllocationLimitExceeded
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String # backtraceDesired :: AllocationLimitExceeded -> Bool #
Exception ArrayException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String # backtraceDesired :: ArrayException -> Bool #
Exception AssertionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String # backtraceDesired :: AssertionFailed -> Bool #
Exception AsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String # backtraceDesired :: AsyncException -> Bool #
Exception BlockedIndefinitelyOnMVar
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String # backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool #
Exception BlockedIndefinitelyOnSTM
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String # backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool #
Exception CompactionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String # backtraceDesired :: CompactionFailed -> Bool #
Exception Deadlock
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String # backtraceDesired :: Deadlock -> Bool #
Exception ExitCode
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool #
Exception FixIOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String # backtraceDesired :: FixIOException -> Bool #
Exception IOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Exception SomeAsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool #
Exception a => Exception (ExceptionWithContext a)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException # fromException :: SomeException -> Maybe (ExceptionWithContext a) # displayException :: ExceptionWithContext a -> String # backtraceDesired :: ExceptionWithContext a -> Bool #
Exception e => Exception (NoBacktrace e)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException # fromException :: SomeException -> Maybe (NoBacktrace e) # displayException :: NoBacktrace e -> String # backtraceDesired :: NoBacktrace e -> Bool #

data SomeException #

Instances

Instances details

Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Show SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS show :: SomeException -> String showList :: [SomeException] -> ShowS

class MonadThrow m => MonadCatch (m :: Type -> Type) where #

Methods

catch :: (HasCallStack, Exception e) => m a -> (e -> m a) -> m a #

Instances

Instances details

MonadCatch STM
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => STM a -> (e -> STM a) -> STM a #
MonadCatch IO
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => IO a -> (e -> IO a) -> IO a #
Monad m => MonadCatch (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods catch :: (HasCallStack, Exception e) => CatchT m a -> (e -> CatchT m a) -> CatchT m a #
e ~ SomeException => MonadCatch (Either e)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e0) => Either e a -> (e0 -> Either e a) -> Either e a #
MonadCatch m => MonadCatch (ListT m)
Instance details Defined in Pipes Methods catch :: (HasCallStack, Exception e) => ListT m a -> (e -> ListT m a) -> ListT m a #
MonadCatch m => MonadCatch (SafeT m) Source #
Instance details Defined in Pipes.Safe Methods catch :: (HasCallStack, Exception e) => SafeT m a -> (e -> SafeT m a) -> SafeT m a #
MonadCatch m => MonadCatch (MaybeT m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadCatch m => MonadCatch (ExceptT e m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e0) => ExceptT e m a -> (e0 -> ExceptT e m a) -> ExceptT e m a #
MonadCatch m => MonadCatch (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a #
MonadCatch m => MonadCatch (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadCatch m => MonadCatch (StateT s m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => StateT s m a -> (e -> StateT s m a) -> StateT s m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods catch :: (HasCallStack, Exception e) => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
MonadCatch m => MonadCatch (Proxy a' a b' b m)
Instance details Defined in Pipes.Internal Methods catch :: (HasCallStack, Exception e) => Proxy a' a b' b m a0 -> (e -> Proxy a' a b' b m a0) -> Proxy a' a b' b m a0 #

class Monad m => MonadThrow (m :: Type -> Type) where #

Methods

throwM :: (HasCallStack, Exception e) => e -> m a #

Instances

Instances details

MonadThrow STM
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> STM a #
MonadThrow IO
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> IO a #
MonadThrow Q
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> Q a #
MonadThrow Maybe
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> Maybe a #
MonadThrow []
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> [a] #
Monad m => MonadThrow (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods throwM :: (HasCallStack, Exception e) => e -> CatchT m a #
e ~ SomeException => MonadThrow (Either e)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e0) => e0 -> Either e a #
MonadThrow (ST s)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ST s a #
MonadThrow m => MonadThrow (ListT m)
Instance details Defined in Pipes Methods throwM :: (HasCallStack, Exception e) => e -> ListT m a #
MonadThrow m => MonadThrow (SafeT m) Source #
Instance details Defined in Pipes.Safe Methods throwM :: (HasCallStack, Exception e) => e -> SafeT m a #
MonadThrow m => MonadThrow (MaybeT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> MaybeT m a #
MonadThrow m => MonadThrow (ExceptT e m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e0) => e0 -> ExceptT e m a #
MonadThrow m => MonadThrow (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> IdentityT m a #
MonadThrow m => MonadThrow (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ReaderT r m a #
MonadThrow m => MonadThrow (StateT s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> StateT s m a #
MonadThrow m => MonadThrow (StateT s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> StateT s m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> WriterT w m a #
(MonadThrow m, Monoid w) => MonadThrow (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> WriterT w m a #
MonadThrow m => MonadThrow (ContT r m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> ContT r m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> RWST r w s m a #
(MonadThrow m, Monoid w) => MonadThrow (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods throwM :: (HasCallStack, Exception e) => e -> RWST r w s m a #
MonadThrow m => MonadThrow (Proxy a' a b' b m)
Instance details Defined in Pipes.Internal Methods throwM :: (HasCallStack, Exception e) => e -> Proxy a' a b' b m a0 #

class MonadCatch m => MonadMask (m :: Type -> Type) where #

Methods

mask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b #

uninterruptibleMask :: HasCallStack => ((forall a. m a -> m a) -> m b) -> m b #

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

Instances

Instances details

MonadMask IO
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. IO a -> IO a) -> IO b) -> IO b # uninterruptibleMask :: HasCallStack => ((forall a. IO a -> IO a) -> IO b) -> IO b # generalBracket :: HasCallStack => IO a -> (a -> ExitCase b -> IO c) -> (a -> IO b) -> IO (b, c) #
Monad m => MonadMask (CatchT m)
Instance details Defined in Control.Monad.Catch.Pure Methods mask :: HasCallStack => ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b # uninterruptibleMask :: HasCallStack => ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b # generalBracket :: HasCallStack => CatchT m a -> (a -> ExitCase b -> CatchT m c) -> (a -> CatchT m b) -> CatchT m (b, c) #
e ~ SomeException => MonadMask (Either e)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # uninterruptibleMask :: HasCallStack => ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b # generalBracket :: HasCallStack => Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #
MonadMask m => MonadMask (SafeT m) Source #
Instance details Defined in Pipes.Safe Methods mask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b # uninterruptibleMask :: HasCallStack => ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b # generalBracket :: HasCallStack => SafeT m a -> (a -> ExitCase b -> SafeT m c) -> (a -> SafeT m b) -> SafeT m (b, c) #
MonadMask m => MonadMask (MaybeT m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # uninterruptibleMask :: HasCallStack => ((forall a. MaybeT m a -> MaybeT m a) -> MaybeT m b) -> MaybeT m b # generalBracket :: HasCallStack => MaybeT m a -> (a -> ExitCase b -> MaybeT m c) -> (a -> MaybeT m b) -> MaybeT m (b, c) #
MonadMask m => MonadMask (ExceptT e m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # uninterruptibleMask :: HasCallStack => ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b # generalBracket :: HasCallStack => ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) #
MonadMask m => MonadMask (IdentityT m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # uninterruptibleMask :: HasCallStack => ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b # generalBracket :: HasCallStack => IdentityT m a -> (a -> ExitCase b -> IdentityT m c) -> (a -> IdentityT m b) -> IdentityT m (b, c) #
MonadMask m => MonadMask (ReaderT r m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # uninterruptibleMask :: HasCallStack => ((forall a. ReaderT r m a -> ReaderT r m a) -> ReaderT r m b) -> ReaderT r m b # generalBracket :: HasCallStack => ReaderT r m a -> (a -> ExitCase b -> ReaderT r m c) -> (a -> ReaderT r m b) -> ReaderT r m (b, c) #
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: HasCallStack => StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
MonadMask m => MonadMask (StateT s m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # uninterruptibleMask :: HasCallStack => ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b # generalBracket :: HasCallStack => StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: HasCallStack => WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (WriterT w m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # uninterruptibleMask :: HasCallStack => ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b # generalBracket :: HasCallStack => WriterT w m a -> (a -> ExitCase b -> WriterT w m c) -> (a -> WriterT w m b) -> WriterT w m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: HasCallStack => RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #
(MonadMask m, Monoid w) => MonadMask (RWST r w s m)
Instance details Defined in Control.Monad.Catch Methods mask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # uninterruptibleMask :: HasCallStack => ((forall a. RWST r w s m a -> RWST r w s m a) -> RWST r w s m b) -> RWST r w s m b # generalBracket :: HasCallStack => RWST r w s m a -> (a -> ExitCase b -> RWST r w s m c) -> (a -> RWST r w s m b) -> RWST r w s m (b, c) #
(MonadMask m, MonadIO m) => MonadMask (Proxy a' a b' b m) Source #
Instance details Defined in Pipes.Safe Methods mask :: HasCallStack => ((forall a0. Proxy a' a b' b m a0 -> Proxy a' a b' b m a0) -> Proxy a' a b' b m b0) -> Proxy a' a b' b m b0 # uninterruptibleMask :: HasCallStack => ((forall a0. Proxy a' a b' b m a0 -> Proxy a' a b' b m a0) -> Proxy a' a b' b m b0) -> Proxy a' a b' b m b0 # generalBracket :: HasCallStack => Proxy a' a b' b m a0 -> (a0 -> ExitCase b0 -> Proxy a' a b' b m c) -> (a0 -> Proxy a' a b' b m b0) -> Proxy a' a b' b m (b0, c) #

data ExitCase a #

Constructors

ExitCaseSuccess a
ExitCaseException SomeException
ExitCaseAbort

Instances

Instances details

Show a => Show (ExitCase a)
Instance details Defined in Control.Monad.Catch Methods showsPrec :: Int -> ExitCase a -> ShowS show :: ExitCase a -> String showList :: [ExitCase a] -> ShowS

mask_ :: (HasCallStack, MonadMask m) => m a -> m a #

uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a #

catchAll :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a #

catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a #

catchJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a #

catchIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a #

data Handler (m :: Type -> Type) a #

Constructors

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

Instances

Instances details

Monad m => Functor (Handler m)
Instance details Defined in Control.Monad.Catch Methods fmap :: (a -> b) -> Handler m a -> Handler m b (<$) :: a -> Handler m b -> Handler m a

catches :: (HasCallStack, Foldable f, MonadCatch m) => m a -> f (Handler m a) -> m a #

handle :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a #

handleAll :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a #

handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a #

handleJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a #

handleIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a #

tryJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a) #

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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

backtraceDesired :: e -> Bool #

Instances

Instances details

Exception Timeout
Instance details Defined in System.Timeout Methods toException :: Timeout -> SomeException # fromException :: SomeException -> Maybe Timeout # displayException :: Timeout -> String # backtraceDesired :: Timeout -> Bool #
Exception Void
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String # backtraceDesired :: Void -> Bool #
Exception ArithException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String # backtraceDesired :: ArithException -> Bool #
Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Exception AllocationLimitExceeded
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String # backtraceDesired :: AllocationLimitExceeded -> Bool #
Exception ArrayException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String # backtraceDesired :: ArrayException -> Bool #
Exception AssertionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String # backtraceDesired :: AssertionFailed -> Bool #
Exception AsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String # backtraceDesired :: AsyncException -> Bool #
Exception BlockedIndefinitelyOnMVar
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String # backtraceDesired :: BlockedIndefinitelyOnMVar -> Bool #
Exception BlockedIndefinitelyOnSTM
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String # backtraceDesired :: BlockedIndefinitelyOnSTM -> Bool #
Exception CompactionFailed
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String # backtraceDesired :: CompactionFailed -> Bool #
Exception Deadlock
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String # backtraceDesired :: Deadlock -> Bool #
Exception ExitCode
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String # backtraceDesired :: ExitCode -> Bool #
Exception FixIOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String # backtraceDesired :: FixIOException -> Bool #
Exception IOException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String # backtraceDesired :: IOException -> Bool #
Exception SomeAsyncException
Instance details Defined in GHC.Internal.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String # backtraceDesired :: SomeAsyncException -> Bool #
Exception a => Exception (ExceptionWithContext a)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: ExceptionWithContext a -> SomeException # fromException :: SomeException -> Maybe (ExceptionWithContext a) # displayException :: ExceptionWithContext a -> String # backtraceDesired :: ExceptionWithContext a -> Bool #
Exception e => Exception (NoBacktrace e)
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: NoBacktrace e -> SomeException # fromException :: SomeException -> Maybe (NoBacktrace e) # displayException :: NoBacktrace e -> String # backtraceDesired :: NoBacktrace e -> Bool #

data SomeException #

Constructors

(Exception e, HasExceptionContext) => SomeException e

Instances

Instances details

Exception SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String # backtraceDesired :: SomeException -> Bool #
Show SomeException
Instance details Defined in GHC.Internal.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS show :: SomeException -> String showList :: [SomeException] -> ShowS

Orphan instances

(MonadMask m, MonadIO m) => MonadMask (Proxy a' a b' b m) Source #

Instance details

Methods

mask :: HasCallStack => ((forall a0. Proxy a' a b' b m a0 -> Proxy a' a b' b m a0) -> Proxy a' a b' b m b0) -> Proxy a' a b' b m b0 #

uninterruptibleMask :: HasCallStack => ((forall a0. Proxy a' a b' b m a0 -> Proxy a' a b' b m a0) -> Proxy a' a b' b m b0) -> Proxy a' a b' b m b0 #

generalBracket :: HasCallStack => Proxy a' a b' b m a0 -> (a0 -> ExitCase b0 -> Proxy a' a b' b m c) -> (a0 -> Proxy a' a b' b m b0) -> Proxy a' a b' b m (b0, c) #