managed-1.0.5: A monad for managed values

Safe Haskell | Safe
Language | Haskell98

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
- managed :: (forall r. (a -> IO r) -> IO r) -> Managed a
- managed_ :: (forall r. IO r -> IO r) -> Managed ()
- runManaged :: Managed () -> IO ()
- module Control.Monad.IO.Class

# Managed

data Managed a #

A managed resource that you acquire using `with`

Instances

Monad Managed # |
Methods (>>=) :: Managed a -> (a -> Managed b) -> Managed b # (>>) :: Managed a -> Managed b -> Managed b # return :: a -> Managed a # fail :: String -> Managed a #
Functor Managed # |
Methods fmap :: (a -> b) -> Managed a -> Managed b # (<$) :: a -> Managed b -> Managed a #
Applicative Managed # |
Methods pure :: a -> Managed a # (<*>) :: Managed (a -> b) -> Managed a -> Managed b # (*>) :: Managed a -> Managed b -> Managed b # (<*) :: Managed a -> Managed b -> Managed a #
MonadIO Managed # |
Methods liftIO :: IO a -> Managed a #
MonadManaged Managed # |
Methods using :: Managed a -> Managed a #
Floating a => Floating (Managed a) # |
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 #
Fractional a => Fractional (Managed a) # |
Methods (/) :: Managed a -> Managed a -> Managed a # recip :: Managed a -> Managed a # fromRational :: Rational -> Managed a #
Num a => Num (Managed a) # |
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 #
Monoid a => Monoid (Managed a) # |
Methods mempty :: Managed a # mappend :: Managed a -> Managed a -> Managed a # mconcat :: [Managed a] -> 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)

Minimal complete definition

using

Methods

using :: Managed a -> m a #

Instances

MonadManaged Managed # |
Methods using :: Managed a -> Managed a #
MonadManaged m => MonadManaged (MaybeT m) # |
Methods using :: Managed a -> MaybeT m a #
(Monoid w, MonadManaged m) => MonadManaged (WriterT w m) # |
Methods using :: Managed a -> WriterT w m a #
(Monoid w, MonadManaged m) => MonadManaged (WriterT w m) # |
Methods using :: Managed a -> WriterT w m a #
MonadManaged m => MonadManaged (StateT s m) # |
Methods using :: Managed a -> StateT s m a #
MonadManaged m => MonadManaged (StateT s m) # |
Methods using :: Managed a -> StateT s m a #
MonadManaged m => MonadManaged (IdentityT * m) # |
Methods using :: Managed a -> IdentityT * m a #
MonadManaged m => MonadManaged (ExceptT e m) # |
Methods using :: Managed a -> ExceptT e m a #
MonadManaged m => MonadManaged (ReaderT * r m) # |
Methods using :: Managed a -> ReaderT * r m a #
MonadManaged m => MonadManaged (ContT * r m) # |
Methods using :: Managed a -> ContT * r m a #
(Monoid w, MonadManaged m) => MonadManaged (RWST r w s m) # |
Methods using :: Managed a -> RWST r w s m a #
(Monoid w, MonadManaged m) => MonadManaged (RWST r w s m) # |
Methods using :: Managed a -> RWST r w s m a #

managed :: (forall r. (a -> IO r) -> IO r) -> Managed a #

Build a `Managed` value

managed_ :: (forall r. IO r -> IO r) -> Managed () #

Like `managed` but for resource-less operations.

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

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

# Re-exports

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

module Control.Monad.IO.Class