Control.Monad.Resource

Allocate resources which are guaranteed to be released.

One point to note: all register cleanup actions live in IO, not the main monad. This allows both more efficient code, and for monads to be transformed.

Data types

data ResourceT m a

The Resource transformer. This transformer keeps track of all registered actions, and calls them upon exit (via runResourceT). Actions may be registered via register, or resources may be allocated atomically via with. The with function corresponds closely to bracket.

Releasing may be performed before exit via the release function. This is a highly recommended optimization, as it will ensure that scarce resources are freed early. Note that calling release will deregister the action, so that a release action will only ever be called once.

Instances

MonadTrans ResourceT

MonadTransControl ResourceT

MonadRWS r w s m => MonadRWS r w s (ResourceT m)

MonadBase b m => MonadBase b (ResourceT m)

MonadBaseControl b m => MonadBaseControl b (ResourceT m)

MonadError e m => MonadError e (ResourceT m)

MonadReader r m => MonadReader r (ResourceT m)

MonadState s m => MonadState s (ResourceT m)

MonadWriter w m => MonadWriter w (ResourceT m)

Monad m => Monad (ResourceT m)

Functor m => Functor (ResourceT m)

Applicative m => Applicative (ResourceT m)

(MonadFork m, MonadBaseControl IO m) => MonadFork (ResourceT m)

MonadIO m => MonadIO (ResourceT m)

MonadCont m => MonadCont (ResourceT m)

data ReleaseKey

A lookup key for a specific release action. This value is returned by register and with and is passed to release.

Run

runResourceT :: MonadBaseControl IO m => ResourceT m a -> m a

Unwrap a ResourceT transformer, and call all registered release actions.

Note that there is some reference counting involved due to the MonadFork instance. If multiple threads are sharing the same collection of resources, only the last call to runResourceT will deallocate the resources.

Resource allocation

with

Arguments

:: MonadBase IO m

=> IO a

allocate

-> (a -> IO ())

free resource

-> ResourceT m (ReleaseKey, a)

Perform some allocation, and automatically register a cleanup action.

register :: MonadBase IO m => IO () -> ResourceT m ReleaseKey

Register some action that will be called precisely once, either when runResourceT is called, or when the ReleaseKey is passed to release.

release :: MonadBase IO m => ReleaseKey -> ResourceT m ()

Call a release action early, and deregister it from the list of cleanup actions to be performed.

Monad transformation

transResourceT :: (m a -> n b) -> ResourceT m a -> ResourceT n b

Transform the monad a ResourceT lives in. This is most often used to strip or add new transformers to a stack, e.g. to run a ReaderT.