managed-1.0.11: A monad for managed values

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 :: Type -> Type) 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 ()
- module Control.Monad.IO.Class

# Managed

data Managed a Source #

A managed resource that you acquire using `with`

#### Instances

Instances details

MonadIO Managed Source # |
Instance details Defined in Control.Monad.Managed Methods liftIO :: IO a -> Managed a Source #
Applicative Managed Source # |
Instance details Defined in Control.Monad.Managed Methods pure :: a -> Managed a Source # (<*>) :: Managed (a -> b) -> Managed a -> Managed b Source # liftA2 :: (a -> b -> c) -> Managed a -> Managed b -> Managed c Source # (*>) :: Managed a -> Managed b -> Managed b Source # (<*) :: Managed a -> Managed b -> Managed a Source #
Functor Managed Source # |
Instance details Defined in Control.Monad.Managed Methods fmap :: (a -> b) -> Managed a -> Managed b Source # (<$) :: a -> Managed b -> Managed a Source #
Monad Managed Source # |
Instance details Defined in Control.Monad.Managed Methods (>>=) :: Managed a -> (a -> Managed b) -> Managed b Source # (>>) :: Managed a -> Managed b -> Managed b Source # return :: a -> Managed a Source #
MonadFail Managed Source # |
Instance details Defined in Control.Monad.Managed Methods fail :: String -> Managed a Source #
MonadManaged Managed Source # |
Instance details Defined in Control.Monad.Managed Methods using :: Managed a -> Managed a Source #
Monoid a => Monoid (Managed a) Source # |
Instance details Defined in Control.Monad.Managed Methods mempty :: Managed a Source # mappend :: Managed a -> Managed a -> Managed a Source # mconcat :: [Managed a] -> Managed a Source #
Semigroup a => Semigroup (Managed a) Source # |
Instance details Defined in Control.Monad.Managed Methods (<>) :: Managed a -> Managed a -> Managed a Source # sconcat :: NonEmpty (Managed a) -> Managed a Source # stimes :: Integral b => b -> Managed a -> Managed a Source #
Floating a => Floating (Managed a) Source # |

Instance details

Defined in Control.Monad.Managed

Methods

pi :: Managed a Source #

exp :: Managed a -> Managed a Source #

log :: Managed a -> Managed a Source #

sqrt :: Managed a -> Managed a Source #

(**) :: Managed a -> Managed a -> Managed a Source #

logBase :: Managed a -> Managed a -> Managed a Source #

sin :: Managed a -> Managed a Source #

cos :: Managed a -> Managed a Source #

tan :: Managed a -> Managed a Source #

asin :: Managed a -> Managed a Source #

acos :: Managed a -> Managed a Source #

atan :: Managed a -> Managed a Source #

sinh :: Managed a -> Managed a Source #

cosh :: Managed a -> Managed a Source #

tanh :: Managed a -> Managed a Source #

asinh :: Managed a -> Managed a Source #

acosh :: Managed a -> Managed a Source #

atanh :: Managed a -> Managed a Source #

log1p :: Managed a -> Managed a Source #

expm1 :: Managed a -> Managed a Source #

log1pexp :: Managed a -> Managed a Source #

log1mexp :: Managed a -> Managed a Source #

Num a => Num (Managed a) Source # |
Instance details Defined in Control.Monad.Managed Methods (+) :: Managed a -> Managed a -> Managed a Source # (-) :: Managed a -> Managed a -> Managed a Source # (*) :: Managed a -> Managed a -> Managed a Source # negate :: Managed a -> Managed a Source # abs :: Managed a -> Managed a Source # signum :: Managed a -> Managed a Source # fromInteger :: Integer -> Managed a Source #
Fractional a => Fractional (Managed a) Source # |
Instance details Defined in Control.Monad.Managed Methods (/) :: Managed a -> Managed a -> Managed a Source # recip :: Managed a -> Managed a Source # fromRational :: Rational -> Managed a Source #

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

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

#### Instances

Instances details

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

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

Build a `Managed` value

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

Like `managed` but for resource-less operations.

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

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 () Source #

Run a `Managed` computation, enforcing that no acquired resources leak

# Re-exports

Control.Monad.IO.Class re-exports `MonadIO`

module Control.Monad.IO.Class