-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Safety for the pipes ecosystem
--   
--   This package adds resource management and exception handling to the
--   pipes ecosystem.
--   
--   Notable features include:
--   
--   
--   
- Resource Safety: Guarantee finalization using
--   finally, bracket and more
--   
- Exception Safety: Even against asynchronous
--   exceptions!
--   
- Laziness: Only acquire resources when you need them
--   
- Promptness: Finalize resources early when you are done with
--   them
--   
- Native Exception Handling: Catch and resume from exceptions
--   inside pipes
--   
- No Buy-in: Mix resource-safe pipes with unmanaged pipes
--   using hoist
--   
@package pipes-safe
@version 2.3.5

-- | 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.
module Pipes.Safe

-- | 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.
newtype SafeT 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.
SafeT :: ReaderT (Env m) m r -> SafeT m r

-- | Run the SafeT monad transformer, executing all unreleased
--   finalizers at the end of the computation
runSafeT :: (MonadMask m, MonadIO m) => SafeT m r -> m r

-- | 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.
runSafeP :: (MonadMask m, MonadIO m) => Effect (SafeT m) r -> Effect' m r

-- | Token used to release a previously registered finalizer
data ReleaseKey

-- | MonadSafe lets you register and release
--   finalizers that execute in a Base monad
class (MonadCatch m, MonadMask m, MonadIO m, MonadIO (Base m)) => MonadSafe m where {
    
    -- | The monad used to run resource management actions, corresponding to
    --   the monad directly beneath <a>SafeT</a>
    type Base (m :: Type -> Type) :: Type -> Type;
}

-- | Lift an action from the Base monad
liftBase :: MonadSafe m => Base m r -> m r

-- | register a finalizer, ensuring that the finalizer gets called
--   if the finalizer is not released before the end of the
--   surrounding SafeT block.
register :: MonadSafe m => Base m () -> m ReleaseKey

-- | release a registered finalizer
--   
--   You can safely call release more than once on the same
--   ReleaseKey. Every release after the first one does
--   nothing.
release :: MonadSafe m => ReleaseKey -> m ()

-- | Analogous to onException from Control.Monad.Catch,
--   except this also protects against premature termination
--   
--   (`onException` io) is a monad morphism.
onException :: MonadSafe m => m a -> Base m b -> m a

-- | Transform a Proxy into one that catches any exceptions caused
--   by its effects, and returns the resulting exception.
tryP :: (MonadSafe m, Exception e) => Proxy a' a b' b m r -> Proxy a' a b' b m (Either e r)

-- | Allows direct handling of exceptions raised by the effects in a
--   Proxy.
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

-- | Analogous to finally from Control.Monad.Catch, except
--   this also protects against premature termination
finally :: MonadSafe m => m a -> Base m b -> m a

-- | Analogous to bracket 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

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

-- | Analogous to bracketOnError 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

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

-- | 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
--   
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e

-- | Render this exception value in a human-friendly manner.
--   
--   Default implementation: show.
displayException :: Exception e => e -> String

-- | 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.
data () => SomeException

-- | Generalized version of Handler
data () => Handler (m :: Type -> Type) a
Handler :: (e -> m a) -> Handler (m :: Type -> Type) a

-- | A MonadMask computation may either succeed with a value, abort
--   with an exception, or abort for some other reason. For example, in
--   ExceptT e IO you can use throwM to abort with an
--   exception (ExitCaseException) or throwE to abort with a
--   value of type e (ExitCaseAbort).
data () => ExitCase a
ExitCaseSuccess :: a -> ExitCase a
ExitCaseException :: SomeException -> ExitCase a
ExitCaseAbort :: ExitCase a

-- | A class for monads which provide for the ability to account for all
--   possible exit points from a computation, and to mask asynchronous
--   exceptions. Continuation-based monads are invalid instances of this
--   class.
--   
--   Instances should ensure that, in the following code:
--   
--   
--   fg = f `finally` g
--   
--   
--   The action g is called regardless of what occurs within
--   f, including async exceptions. Some monads allow f
--   to abort the computation via other effects than throwing an exception.
--   For simplicity, we will consider aborting and throwing an exception to
--   be two forms of "throwing an error".
--   
--   If f and g both throw an error, the error thrown by
--   fg depends on which errors we're talking about. In a monad
--   transformer stack, the deeper layers override the effects of the inner
--   layers; for example, ExceptT e1 (Except e2) a represents a
--   value of type Either e2 (Either e1 a), so throwing both an
--   e1 and an e2 will result in Left e2. If
--   f and g both throw an error from the same layer,
--   instances should ensure that the error from g wins.
--   
--   Effects other than throwing an error are also overridden by the deeper
--   layers. For example, StateT s Maybe a represents a value of
--   type s -> Maybe (a, s), so if an error thrown from
--   f causes this function to return Nothing, any
--   changes to the state which f also performed will be erased.
--   As a result, g will see the state as it was before
--   f. Once g completes, f's error will be
--   rethrown, so g' state changes will be erased as well. This is
--   the normal interaction between effects in a monad transformer stack.
--   
--   By contrast, lifted-base's version of finally always
--   discards all of g's non-IO effects, and g never sees
--   any of f's non-IO effects, regardless of the layer ordering
--   and regardless of whether f throws an error. This is not the
--   result of interacting effects, but a consequence of
--   MonadBaseControl's approach.
class MonadCatch m => MonadMask (m :: Type -> Type)

-- | Runs an action with asynchronous exceptions disabled. The action is
--   provided a method for restoring the async. environment to what it was
--   at the mask call. See Control.Exception's mask.
mask :: (MonadMask m, HasCallStack) => ((forall a. () => m a -> m a) -> m b) -> m b

-- | Like mask, but the masked computation is not interruptible (see
--   Control.Exception's uninterruptibleMask. WARNING: Only
--   use if you need to mask exceptions around an interruptible operation
--   AND you can guarantee the interruptible operation will only block for
--   a short period of time. Otherwise you render the program/thread
--   unresponsive and/or unkillable.
uninterruptibleMask :: (MonadMask m, HasCallStack) => ((forall a. () => m a -> m a) -> m b) -> m b

-- | A generalized version of bracket which uses ExitCase to
--   distinguish the different exit cases, and returns the values of both
--   the use and release actions. In practice, this extra
--   information is rarely needed, so it is often more convenient to use
--   one of the simpler functions which are defined in terms of this one,
--   such as bracket, finally, onError, and
--   bracketOnError.
--   
--   This function exists because in order to thread their effects through
--   the execution of bracket, monad transformers need values to be
--   threaded from use to release and from
--   release to the output value.
--   
--   NOTE This method was added in version 0.9.0 of this library.
--   Previously, implementation of functions like bracket and
--   finally in this module were based on the mask and
--   uninterruptibleMask functions only, disallowing some classes of
--   tranformers from having MonadMask instances (notably
--   multi-exit-point transformers like ExceptT). If you are a
--   library author, you'll now need to provide an implementation for this
--   method. The StateT implementation demonstrates most of the
--   subtleties:
--   
--   
--   generalBracket acquire release use = StateT $ s0 -> do
--     ((b, _s2), (c, s3)) <- generalBracket
--       (runStateT acquire s0)
--       ((resource, s1) exitCase -> case exitCase of
--         ExitCaseSuccess (b, s2) -> runStateT (release resource (ExitCaseSuccess b)) s2
--   
--         -- In the two other cases, the base monad overrides use's state
--         -- changes and the state reverts to s1.
--         ExitCaseException e     -> runStateT (release resource (ExitCaseException e)) s1
--         ExitCaseAbort           -> runStateT (release resource ExitCaseAbort) s1
--       )
--       ((resource, s1) -> runStateT (use resource) s1)
--     return ((b, c), s3)
--   
--   
--   The StateT s m implementation of generalBracket
--   delegates to the m implementation of generalBracket.
--   The acquire, use, and release arguments
--   given to StateT's implementation produce actions of type
--   StateT s m a, StateT s m b, and StateT s m
--   c. In order to run those actions in the base monad, we need to
--   call runStateT, from which we obtain actions of type m
--   (a, s), m (b, s), and m (c, s). Since each
--   action produces the next state, it is important to feed the state
--   produced by the previous action to the next action.
--   
--   In the ExitCaseSuccess case, the state starts at s0,
--   flows through acquire to become s1, flows through
--   use to become s2, and finally flows through
--   release to become s3. In the other two cases,
--   release does not receive the value s2, so its action
--   cannot see the state changes performed by use. This is fine,
--   because in those two cases, an error was thrown in the base monad, so
--   as per the usual interaction between effects in a monad transformer
--   stack, those state changes get reverted. So we start from s1
--   instead.
--   
--   Finally, the m implementation of generalBracket
--   returns the pairs (b, s) and (c, s). For monad
--   transformers other than StateT, this will be some other type
--   representing the effects and values performed and returned by the
--   use and release actions. The effect part of the
--   use result, in this case _s2, usually needs to be
--   discarded, since those effects have already been incorporated in the
--   release action.
--   
--   The only effect which is intentionally not incorporated in the
--   release action is the effect of throwing an error. In that
--   case, the error must be re-thrown. One subtlety which is easy to miss
--   is that in the case in which use and release both
--   throw an error, the error from release should take priority.
--   Here is an implementation for ExceptT which demonstrates how
--   to do this.
--   
--   
--   generalBracket acquire release use = ExceptT $ do
--     (eb, ec) <- generalBracket
--       (runExceptT acquire)
--       (eresource exitCase -> case eresource of
--         Left e -> return (Left e) -- nothing to release, acquire didn't succeed
--         Right resource -> case exitCase of
--           ExitCaseSuccess (Right b) -> runExceptT (release resource (ExitCaseSuccess b))
--           ExitCaseException e       -> runExceptT (release resource (ExitCaseException e))
--           _                         -> runExceptT (release resource ExitCaseAbort))
--       (either (return . Left) (runExceptT . use))
--     return $ do
--       -- The order in which we perform those two Either effects determines
--       -- which error will win if they are both Lefts. We want the error from
--       -- release to win.
--       c <- ec
--       b <- eb
--       return (b, c)
--   
generalBracket :: (MonadMask m, HasCallStack) => m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)

-- | A class for monads which allow exceptions to be caught, in particular
--   exceptions which were thrown by throwM.
--   
--   Instances should obey the following law:
--   
--   
--   catch (throwM e) f = f e
--   
--   
--   Note that the ability to catch an exception does not guarantee
--   that we can deal with all possible exit points from a computation.
--   Some monads, such as continuation-based stacks, allow for more than
--   just a success/failure strategy, and therefore catch
--   cannot be used by those monads to properly implement a function
--   such as finally. For more information, see MonadMask.
class MonadThrow m => MonadCatch (m :: Type -> Type)

-- | Provide a handler for exceptions thrown during execution of the first
--   action. Note that type of the type of the argument to the handler will
--   constrain which exceptions are caught. See Control.Exception's
--   catch.
catch :: (MonadCatch m, HasCallStack, Exception e) => m a -> (e -> m a) -> m a

-- | A class for monads in which exceptions may be thrown.
--   
--   Instances should obey the following law:
--   
--   
--   throwM e >> x = throwM e
--   
--   
--   In other words, throwing an exception short-circuits the rest of the
--   monadic computation.
class Monad m => MonadThrow (m :: Type -> Type)

-- | Throw an exception. Note that this throws when this action is run in
--   the monad m, not when it is applied. It is a generalization
--   of Control.Exception's throwIO.
--   
--   Should satisfy the law:
--   
--   
--   throwM e >> f = throwM e
--   
throwM :: (MonadThrow m, HasCallStack, Exception e) => e -> m a

-- | Like mask, but does not pass a restore action to the
--   argument.
mask_ :: (HasCallStack, MonadMask m) => m a -> m a

-- | Like uninterruptibleMask, but does not pass a restore
--   action to the argument.
uninterruptibleMask_ :: (HasCallStack, MonadMask m) => m a -> m a

-- | A more generalized way of determining which exceptions to catch at run
--   time.
catchJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a

-- | Flipped catch. See Control.Exception's handle.
handle :: (HasCallStack, MonadCatch m, Exception e) => (e -> m a) -> m a -> m a

-- | Flipped catchJust. See Control.Exception's
--   handleJust.
handleJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a

-- | A variant of try that takes an exception predicate to select
--   which exceptions are caught. See Control.Exception's
--   tryJust
tryJust :: (HasCallStack, MonadCatch m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)

-- | Catches different sorts of exceptions. See Control.Exception's
--   catches
catches :: (HasCallStack, Foldable f, MonadCatch m) => m a -> f (Handler m a) -> m a

-- | Catch all IOError (eqv. IOException) exceptions. Still
--   somewhat too general, but better than using catchAll. See
--   catchIf for an easy way of catching specific IOErrors
--   based on the predicates in System.IO.Error.
catchIOError :: (HasCallStack, MonadCatch m) => m a -> (IOError -> m a) -> m a

-- | Catches all exceptions, and somewhat defeats the purpose of the
--   extensible exception system. Use sparingly.
--   
--   NOTE This catches all exceptions, but if the monad
--   supports other ways of aborting the computation, those other kinds of
--   errors will not be caught.
catchAll :: (HasCallStack, MonadCatch m) => m a -> (SomeException -> m a) -> m a

-- | Catch exceptions only if they pass some predicate. Often useful with
--   the predicates for testing IOError values in
--   System.IO.Error.
catchIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> m a -> (e -> m a) -> m a

-- | Flipped catchIOError
handleIOError :: (HasCallStack, MonadCatch m) => (IOError -> m a) -> m a -> m a

-- | Flipped catchAll
handleAll :: (HasCallStack, MonadCatch m) => (SomeException -> m a) -> m a -> m a

-- | Flipped catchIf
handleIf :: (HasCallStack, MonadCatch m, Exception e) => (e -> Bool) -> (e -> m a) -> m a -> m a

-- | 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
--   
class (Typeable e, Show e) => Exception e
toException :: Exception e => e -> SomeException
fromException :: Exception e => SomeException -> Maybe e

-- | Render this exception value in a human-friendly manner.
--   
--   Default implementation: show.
displayException :: Exception e => e -> String

-- | 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.
data () => SomeException
SomeException :: e -> SomeException
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Pipes.Safe.SafeT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Pipes.Safe.SafeT m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Pipes.Safe.SafeT m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Pipes.Safe.SafeT m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Pipes.Safe.SafeT m)
instance Control.Monad.Cont.Class.MonadCont m => Control.Monad.Cont.Class.MonadCont (Pipes.Safe.SafeT m)
instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Pipes.Safe.SafeT m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Pipes.Safe.SafeT m)
instance Control.Monad.Error.Class.MonadError e m => Control.Monad.Error.Class.MonadError e (Pipes.Safe.SafeT m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Pipes.Safe.SafeT m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Pipes.Safe.SafeT m)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Pipes.Safe.SafeT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Pipes.Safe.SafeT m)
instance GHC.Base.Alternative m => GHC.Base.Alternative (Pipes.Safe.SafeT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Pipes.Safe.SafeT m)
instance GHC.Base.Functor m => GHC.Base.Functor (Pipes.Safe.SafeT m)
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadCatch m, Control.Monad.Catch.MonadMask m) => Pipes.Safe.MonadSafe (Pipes.Safe.SafeT m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Pipes.Internal.Proxy a' a b' b m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Control.Monad.Trans.Identity.IdentityT m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Control.Monad.Catch.Pure.CatchT m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Control.Monad.Trans.Reader.ReaderT i m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Control.Monad.Trans.State.Lazy.StateT s m)
instance Pipes.Safe.MonadSafe m => Pipes.Safe.MonadSafe (Control.Monad.Trans.State.Strict.StateT s m)
instance (Pipes.Safe.MonadSafe m, GHC.Base.Monoid w) => Pipes.Safe.MonadSafe (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (Pipes.Safe.MonadSafe m, GHC.Base.Monoid w) => Pipes.Safe.MonadSafe (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance (Pipes.Safe.MonadSafe m, GHC.Base.Monoid w) => Pipes.Safe.MonadSafe (Control.Monad.Trans.RWS.Lazy.RWST i w s m)
instance (Pipes.Safe.MonadSafe m, GHC.Base.Monoid w) => Pipes.Safe.MonadSafe (Control.Monad.Trans.RWS.Strict.RWST i w s m)
instance Control.Monad.Trans.Class.MonadTrans Pipes.Safe.SafeT
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Pipes.Safe.SafeT m)
instance Control.Monad.Primitive.PrimMonad m => Control.Monad.Primitive.PrimMonad (Pipes.Safe.SafeT m)
instance (Control.Monad.Catch.MonadMask m, Control.Monad.IO.Class.MonadIO m) => Control.Monad.Catch.MonadMask (Pipes.Internal.Proxy a' a b' b m)

-- | Simple resource management functions
module Pipes.Safe.Prelude

-- | Acquire a Handle within MonadSafe
--   
--   The file is opened in text mode. See also: withBinaryFile
withFile :: MonadSafe m => FilePath -> IOMode -> (Handle -> m r) -> m r

-- | Like withFile, but open the file in binary mode
--   
--   See hSetBinaryMode for the differences between binary and text
--   mode.
withBinaryFile :: MonadSafe m => FilePath -> IOMode -> (Handle -> m r) -> m r

-- | Acquire a Handle within MonadSafe
--   
--   The ReleaseKey can be used to close the handle with
--   release; otherwise the handle will be closed automatically at
--   the conclusion of the MonadSafe block.
--   
--   The file is opened in text mode. See also: openBinaryFile
openFile :: MonadSafe m => FilePath -> IOMode -> m (ReleaseKey, Handle)

-- | Like openFile, but open the file in binary mode
--   
--   See hSetBinaryMode for the differences between binary and text
--   mode.
openBinaryFile :: MonadSafe m => FilePath -> IOMode -> m (ReleaseKey, Handle)

-- | Read lines from a file, automatically opening and closing the file as
--   necessary
readFile :: MonadSafe m => FilePath -> Producer' String m ()

-- | Write lines to a file, automatically opening and closing the file as
--   necessary
writeFile :: MonadSafe m => FilePath -> Consumer' String m r

-- | Acquire some resource with a guarantee that it will eventually be
--   released
--   
--   The ReleaseKey can be passed to release to release the
--   resource manually. If this has not been done by the end of the
--   MonadSafe block, the resource will be released automatically.
allocate :: MonadSafe m => Base m a -> (a -> Base m ()) -> m (ReleaseKey, a)

-- | Like allocate, but for when the resource itself is not needed
--   
--   The acquire action runs immediately. The ReleaseKey can be
--   passed to release to run the release action. If this has not
--   been done by the end of the MonadSafe block, the release action
--   will be run automatically.
allocate_ :: MonadSafe m => Base m a -> Base m () -> m ReleaseKey
