Control.Monad.Managed.Safe

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.

Managed

data Managed a

A managed resource that you acquire using with

Instances

MonadFail Managed

Defined in Control.Monad.Managed

Methods

fail :: String -> Managed a

MonadIO Managed

Defined in Control.Monad.Managed

Methods

liftIO :: IO a -> Managed a

Applicative Managed

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

Defined in Control.Monad.Managed

Methods

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

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

Monad Managed

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

Defined in Control.Monad.Managed

Methods

using :: Managed a -> Managed a

Monoid a => Monoid (Managed a)

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)

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)

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)

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)

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

MonadManaged Managed

Defined in Control.Monad.Managed

Methods

using :: Managed a -> Managed a

MonadManaged m => MonadManaged (MaybeT m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> MaybeT m a

MonadManaged m => MonadManaged (ExceptT e m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> ExceptT e m a

MonadManaged m => MonadManaged (IdentityT m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> IdentityT m a

MonadManaged m => MonadManaged (ReaderT r m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> ReaderT r m a

MonadManaged m => MonadManaged (StateT s m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> StateT s m a

MonadManaged m => MonadManaged (StateT s m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> StateT s m a

(Monoid w, MonadManaged m) => MonadManaged (WriterT w m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> WriterT w m a

(Monoid w, MonadManaged m) => MonadManaged (WriterT w m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> WriterT w m a

MonadManaged m => MonadManaged (ContT r m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> ContT r m a

(Monoid w, MonadManaged m) => MonadManaged (RWST r w s m)

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)

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

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Managed

Defined in Control.Monad.Managed

Methods

liftIO :: IO a -> Managed a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

liftIO :: IO a -> ContT r m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

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)

Defined in Control.Monad.Trans.RWS.Strict

Methods

liftIO :: IO a -> RWST r w s m a