Safe Haskell	Safe-Inferred
Language	Haskell2010

Control.Monad.Managed.Safe

Contents

Managed
Re-exports

Description

This module is a safer subset of Control.Monad.Managed that only lets you unwrap the Managed type using runManaged. This enforces that you never leak acquired resources from a Managed computation.

In general, you should strive to propagate the Managed type as much as possible and use runManaged when you are done with acquired resources. However, there are legitimate circumstances where you want to return a value other than acquired resource from the bracketed computation, which requires using with.

This module is not the default because you can also use the Managed type for callback-based code that is completely unrelated to resources.

Synopsis

data Managed a
class MonadIO m => MonadManaged m where
- using :: Managed a -> m a
managed :: MonadManaged m => (forall r. (a -> IO r) -> IO r) -> m a
managed_ :: MonadManaged m => (forall r. IO r -> IO r) -> m ()
defer :: MonadManaged m => IO r -> m ()
runManaged :: Managed () -> IO ()
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a

Managed

data Managed a #

A managed resource that you acquire using with

Instances

Instances details

MonadFail Managed #
Instance details Defined in Control.Monad.Managed Methods fail :: String -> Managed a
MonadIO Managed #
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a #
Applicative Managed #
Instance details Defined in Control.Monad.Managed Methods pure :: a -> Managed a (<>) :: Managed (a -> b) -> Managed a -> Managed b liftA2 :: (a -> b -> c) -> Managed a -> Managed b -> Managed c (>) :: Managed a -> Managed b -> Managed b (<*) :: Managed a -> Managed b -> Managed a
Functor Managed #
Instance details Defined in Control.Monad.Managed Methods fmap :: (a -> b) -> Managed a -> Managed b (<$) :: a -> Managed b -> Managed a
Monad Managed #
Instance details Defined in Control.Monad.Managed Methods (>>=) :: Managed a -> (a -> Managed b) -> Managed b (>>) :: Managed a -> Managed b -> Managed b return :: a -> Managed a
MonadManaged Managed #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> Managed a #
Monoid a => Monoid (Managed a) #
Instance details Defined in Control.Monad.Managed Methods mempty :: Managed a mappend :: Managed a -> Managed a -> Managed a mconcat :: [Managed a] -> Managed a
Semigroup a => Semigroup (Managed a) #
Instance details Defined in Control.Monad.Managed Methods (<>) :: Managed a -> Managed a -> Managed a sconcat :: NonEmpty (Managed a) -> Managed a stimes :: Integral b => b -> Managed a -> Managed a
Floating a => Floating (Managed a) #
Instance details Defined in Control.Monad.Managed Methods pi :: Managed a exp :: Managed a -> Managed a log :: Managed a -> Managed a sqrt :: Managed a -> Managed a (**) :: Managed a -> Managed a -> Managed a logBase :: Managed a -> Managed a -> Managed a sin :: Managed a -> Managed a cos :: Managed a -> Managed a tan :: Managed a -> Managed a asin :: Managed a -> Managed a acos :: Managed a -> Managed a atan :: Managed a -> Managed a sinh :: Managed a -> Managed a cosh :: Managed a -> Managed a tanh :: Managed a -> Managed a asinh :: Managed a -> Managed a acosh :: Managed a -> Managed a atanh :: Managed a -> Managed a log1p :: Managed a -> Managed a expm1 :: Managed a -> Managed a log1pexp :: Managed a -> Managed a log1mexp :: Managed a -> Managed a
Num a => Num (Managed a) #
Instance details Defined in Control.Monad.Managed Methods (+) :: Managed a -> Managed a -> Managed a (-) :: Managed a -> Managed a -> Managed a (*) :: Managed a -> Managed a -> Managed a negate :: Managed a -> Managed a abs :: Managed a -> Managed a signum :: Managed a -> Managed a fromInteger :: Integer -> Managed a
Fractional a => Fractional (Managed a) #
Instance details Defined in Control.Monad.Managed Methods (/) :: Managed a -> Managed a -> Managed a recip :: Managed a -> Managed a fromRational :: Rational -> Managed a

class MonadIO m => MonadManaged m where #

You can embed a Managed action within any Monad that implements MonadManaged by using the using function

All instances must obey the following two laws:

using (return x) = return x

using (m >>= f) = using m >>= \x -> using (f x)

Methods

using :: Managed a -> m a #

Instances

Instances details

MonadManaged Managed #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> Managed a #
MonadManaged m => MonadManaged (MaybeT m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> MaybeT m a #
MonadManaged m => MonadManaged (ExceptT e m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> ExceptT e m a #
MonadManaged m => MonadManaged (IdentityT m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> IdentityT m a #
MonadManaged m => MonadManaged (ReaderT r m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> ReaderT r m a #
MonadManaged m => MonadManaged (StateT s m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> StateT s m a #
MonadManaged m => MonadManaged (StateT s m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> StateT s m a #
(Monoid w, MonadManaged m) => MonadManaged (WriterT w m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> WriterT w m a #
(Monoid w, MonadManaged m) => MonadManaged (WriterT w m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> WriterT w m a #
MonadManaged m => MonadManaged (ContT r m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> ContT r m a #
(Monoid w, MonadManaged m) => MonadManaged (RWST r w s m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> RWST r w s m a #
(Monoid w, MonadManaged m) => MonadManaged (RWST r w s m) #
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> RWST r w s m a #

managed :: MonadManaged m => (forall r. (a -> IO r) -> IO r) -> m a #

Build a Managed value

managed_ :: MonadManaged m => (forall r. IO r -> IO r) -> m () #

Like managed but for resource-less operations.

defer :: MonadManaged m => IO r -> m () #

Defer running an action until exit (via runManaged).

For example, the following code will print "Hello" followed by "Goodbye":

runManaged $ do
  defer $ liftIO $ putStrLn "Goodbye"
  liftIO $ putStrLn "Hello"

runManaged :: Managed () -> IO () #

Run a Managed computation, enforcing that no acquired resources leak

Re-exports

Control.Monad.IO.Class re-exports MonadIO

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

Methods

liftIO :: IO a -> m a #

Instances

Instances details

MonadIO IO
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Managed #
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a #