pipes-safe-2.3.1: Safety for the pipes ecosystem

Safe HaskellTrustworthy
LanguageHaskell98

Pipes.Safe

Contents

Description

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

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

... so you can throw and catch exceptions within pipes using all MonadCatch operations.

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

SafeT

data SafeT m 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.

Instances
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

Associated Types

type StM (SafeT m) a :: Type

Methods

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

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

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

Defined in Pipes.Safe

Methods

liftBase :: b α -> SafeT m α

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

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

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

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

fail :: String -> 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

MonadFix m => MonadFix (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Methods

mfix :: (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

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

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]

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

MonadCatch m => MonadCatch (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Methods

catch :: 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 :: ((forall a. SafeT m a -> SafeT m a) -> SafeT m b) -> SafeT m b #

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

generalBracket :: 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 :: Exception e => e -> SafeT m a #

MonadIO m => MonadIO (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Methods

liftIO :: IO 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

PrimMonad m => PrimMonad (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Associated Types

type PrimState (SafeT m) :: Type

Methods

primitive :: (State# (PrimState (SafeT m)) -> (#State# (PrimState (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) :: Type -> Type Source #

type PrimState (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

type PrimState (SafeT m) = PrimState m
type Base (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

type Base (SafeT m) = 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 :: (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 where Source #

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

Associated Types

type Base (m :: * -> *) :: * -> * 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
MonadSafe m => MonadSafe (CatchT m) Source # 
Instance details

Defined in Pipes.Safe

Associated Types

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

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) :: Type -> Type Source #

MonadSafe m => MonadSafe (IdentityT m) Source # 
Instance details

Defined in Pipes.Safe

Associated Types

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

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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) :: Type -> Type Source #

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

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 #

Instances
Exception ArithException 
Instance details

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException #

fromException :: SomeException -> Maybe ArithException #

displayException :: ArithException -> String #

Exception SomeException 
Instance details

Defined in GHC.Exception.Type

Exception AllocationLimitExceeded 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException #

fromException :: SomeException -> Maybe AllocationLimitExceeded #

displayException :: AllocationLimitExceeded -> String #

Exception ArrayException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException #

fromException :: SomeException -> Maybe ArrayException #

displayException :: ArrayException -> String #

Exception AssertionFailed 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException #

fromException :: SomeException -> Maybe AssertionFailed #

displayException :: AssertionFailed -> String #

Exception AsyncException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException #

fromException :: SomeException -> Maybe AsyncException #

displayException :: AsyncException -> String #

Exception BlockedIndefinitelyOnMVar 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException #

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar #

displayException :: BlockedIndefinitelyOnMVar -> String #

Exception BlockedIndefinitelyOnSTM 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException #

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM #

displayException :: BlockedIndefinitelyOnSTM -> String #

Exception CompactionFailed 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException #

fromException :: SomeException -> Maybe CompactionFailed #

displayException :: CompactionFailed -> String #

Exception Deadlock 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException #

fromException :: SomeException -> Maybe Deadlock #

displayException :: Deadlock -> String #

Exception IOException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException #

fromException :: SomeException -> Maybe IOException #

displayException :: IOException -> String #

Exception SomeAsyncException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException #

fromException :: SomeException -> Maybe SomeAsyncException #

displayException :: SomeAsyncException -> String #

Exception Void 
Instance details

Defined in Data.Void

Methods

toException :: Void -> SomeException #

fromException :: SomeException -> Maybe Void #

displayException :: Void -> String #

Exception ExitCode 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException #

fromException :: SomeException -> Maybe ExitCode #

displayException :: ExitCode -> String #

Exception FixIOException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: FixIOException -> SomeException #

fromException :: SomeException -> Maybe FixIOException #

displayException :: FixIOException -> String #

data SomeException #

Instances
Show SomeException 
Instance details

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Exception SomeException 
Instance details

Defined in GHC.Exception.Type

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

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

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

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

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

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

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

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

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

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

mask_ :: MonadMask m => m a -> m a #

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

uninterruptibleMask_ :: MonadMask m => m a -> m a #

data ExitCase a #

Instances
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

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

Constructors

Handler :: forall (m :: Type -> Type) a e. Exception e => (e -> m a) -> Handler m a 
Instances
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

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

Methods

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

Instances
MonadCatch IO 
Instance details

Defined in Control.Monad.Catch

Methods

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

MonadCatch STM 
Instance details

Defined in Control.Monad.Catch

Methods

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

e ~ SomeException => MonadCatch (Either e) 
Instance details

Defined in Control.Monad.Catch

Methods

catch :: Exception e0 => Either e a -> (e0 -> Either e a) -> Either e a #

MonadCatch m => MonadCatch (ListT m) 
Instance details

Defined in Control.Monad.Catch

Methods

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

MonadCatch m => MonadCatch (MaybeT m) 
Instance details

Defined in Control.Monad.Catch

Methods

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

Monad m => MonadCatch (CatchT m) 
Instance details

Defined in Control.Monad.Catch.Pure

Methods

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

MonadCatch m => MonadCatch (ListT m) 
Instance details

Defined in Pipes

Methods

catch :: 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 :: Exception e => SafeT m a -> (e -> SafeT m a) -> SafeT m a #

(Error e, MonadCatch m) => MonadCatch (ErrorT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

catch :: Exception e0 => ErrorT e m a -> (e0 -> ErrorT e m a) -> ErrorT e m a #

MonadCatch m => MonadCatch (ExceptT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

catch :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 MonadCatch m => MonadMask (m :: Type -> Type) where #

Methods

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

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

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

Instances
MonadMask IO 
Instance details

Defined in Control.Monad.Catch

Methods

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

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

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

e ~ SomeException => MonadMask (Either e) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

uninterruptibleMask :: ((forall a. Either e a -> Either e a) -> Either e b) -> Either e b #

generalBracket :: Either e a -> (a -> ExitCase b -> Either e c) -> (a -> Either e b) -> Either e (b, c) #

MonadMask m => MonadMask (MaybeT m) 
Instance details

Defined in Control.Monad.Catch

Methods

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

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

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

Monad m => MonadMask (CatchT m) 
Instance details

Defined in Control.Monad.Catch.Pure

Methods

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

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

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

MonadMask m => MonadMask (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Methods

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

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

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

(Error e, MonadMask m) => MonadMask (ErrorT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b #

uninterruptibleMask :: ((forall a. ErrorT e m a -> ErrorT e m a) -> ErrorT e m b) -> ErrorT e m b #

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

MonadMask m => MonadMask (ExceptT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b #

uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b #

generalBracket :: 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 :: ((forall a. IdentityT m a -> IdentityT m a) -> IdentityT m b) -> IdentityT m b #

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

generalBracket :: 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 :: ((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 #

generalBracket :: 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 :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

generalBracket :: 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 :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b #

generalBracket :: 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 :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

generalBracket :: 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 :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

uninterruptibleMask :: ((forall a. WriterT w m a -> WriterT w m a) -> WriterT w m b) -> WriterT w m b #

generalBracket :: 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 :: ((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 :: ((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 :: 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 :: ((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 :: ((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 :: 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 :: ((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 :: ((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 :: 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) #

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

Methods

throwM :: Exception e => e -> m a #

Instances
MonadThrow [] 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> [a] #

MonadThrow Maybe 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> Maybe a #

MonadThrow IO 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> IO a #

MonadThrow Q 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> Q a #

MonadThrow STM 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> STM a #

e ~ SomeException => MonadThrow (Either e) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e0 => e0 -> Either e a #

MonadThrow m => MonadThrow (ListT m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> ListT m a #

MonadThrow m => MonadThrow (MaybeT m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> MaybeT m a #

Monad m => MonadThrow (CatchT m) 
Instance details

Defined in Control.Monad.Catch.Pure

Methods

throwM :: Exception e => e -> CatchT m a #

MonadThrow m => MonadThrow (ListT m) 
Instance details

Defined in Pipes

Methods

throwM :: Exception e => e -> ListT m a #

MonadThrow m => MonadThrow (SafeT m) Source # 
Instance details

Defined in Pipes.Safe

Methods

throwM :: Exception e => e -> SafeT m a #

(Error e, MonadThrow m) => MonadThrow (ErrorT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e0 => e0 -> ErrorT e m a #

MonadThrow m => MonadThrow (ExceptT e m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e0 => e0 -> ExceptT e m a #

MonadThrow m => MonadThrow (IdentityT m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> IdentityT m a #

MonadThrow m => MonadThrow (ReaderT r m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> ReaderT r m a #

MonadThrow m => MonadThrow (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> StateT s m a #

MonadThrow m => MonadThrow (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> StateT s m a #

(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> WriterT w m a #

(MonadThrow m, Monoid w) => MonadThrow (WriterT w m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> WriterT w m a #

MonadThrow m => MonadThrow (ContT r m) 
Instance details

Defined in Control.Monad.Catch

Methods

throwM :: 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 :: 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 :: 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 :: Exception e => e -> Proxy a' a b' b m a0 #

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

Minimal complete definition

Nothing

Methods

toException :: e -> SomeException #

fromException :: SomeException -> Maybe e #

displayException :: e -> String #

Instances
Exception ArithException 
Instance details

Defined in GHC.Exception.Type

Methods

toException :: ArithException -> SomeException #

fromException :: SomeException -> Maybe ArithException #

displayException :: ArithException -> String #

Exception SomeException 
Instance details

Defined in GHC.Exception.Type

Exception AllocationLimitExceeded 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AllocationLimitExceeded -> SomeException #

fromException :: SomeException -> Maybe AllocationLimitExceeded #

displayException :: AllocationLimitExceeded -> String #

Exception ArrayException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: ArrayException -> SomeException #

fromException :: SomeException -> Maybe ArrayException #

displayException :: ArrayException -> String #

Exception AssertionFailed 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AssertionFailed -> SomeException #

fromException :: SomeException -> Maybe AssertionFailed #

displayException :: AssertionFailed -> String #

Exception AsyncException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: AsyncException -> SomeException #

fromException :: SomeException -> Maybe AsyncException #

displayException :: AsyncException -> String #

Exception BlockedIndefinitelyOnMVar 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnMVar -> SomeException #

fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar #

displayException :: BlockedIndefinitelyOnMVar -> String #

Exception BlockedIndefinitelyOnSTM 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: BlockedIndefinitelyOnSTM -> SomeException #

fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM #

displayException :: BlockedIndefinitelyOnSTM -> String #

Exception CompactionFailed 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: CompactionFailed -> SomeException #

fromException :: SomeException -> Maybe CompactionFailed #

displayException :: CompactionFailed -> String #

Exception Deadlock 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: Deadlock -> SomeException #

fromException :: SomeException -> Maybe Deadlock #

displayException :: Deadlock -> String #

Exception IOException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException #

fromException :: SomeException -> Maybe IOException #

displayException :: IOException -> String #

Exception SomeAsyncException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: SomeAsyncException -> SomeException #

fromException :: SomeException -> Maybe SomeAsyncException #

displayException :: SomeAsyncException -> String #

Exception Void 
Instance details

Defined in Data.Void

Methods

toException :: Void -> SomeException #

fromException :: SomeException -> Maybe Void #

displayException :: Void -> String #

Exception ExitCode 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: ExitCode -> SomeException #

fromException :: SomeException -> Maybe ExitCode #

displayException :: ExitCode -> String #

Exception FixIOException 
Instance details

Defined in GHC.IO.Exception

Methods

toException :: FixIOException -> SomeException #

fromException :: SomeException -> Maybe FixIOException #

displayException :: FixIOException -> String #

data SomeException where #

Constructors

SomeException :: forall e. Exception e => e -> SomeException 
Instances
Show SomeException 
Instance details

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

Exception SomeException 
Instance details

Defined in GHC.Exception.Type

Orphan instances

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

Methods

mask :: ((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 :: ((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 :: 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) #