Control.ContStuff.Classes

This module implements the various effect classes supported by contstuff.

Effect classes

Abortion

class Abortable m where

Monads supporting abortion.

Associated Types

type Result m

End result of the computation.

Methods

abort :: Result m -> m a

Ignore current continuation and abort.

Instances

Applicative m => Abortable (MaybeT r m)

Applicative m => Abortable (ContT r m)

Applicative m => Abortable (StateT r s m)

Applicative m => Abortable (EitherT r e m)

Applicative m => Abortable (ChoiceT r i m)

Call with current continuation

class CallCC m where

Monads supporting *call-with-current-continuation* (aka callCC).

Methods

callCC :: ((a -> m b) -> m a) -> m a

Call with current continuation.

Instances

CallCC (MaybeT r m)

CallCC (ContT r m)

CallCC (StateT r s m)

CallCC (EitherT r e m)

data Label m a

A jump label for labelCC and goto.

labelCC :: (Applicative m, CallCC m) => a -> m (a, Label m a)

Capture the current continuation for later use.

goto :: Label m a -> a -> m ()

Jump to a label.

Multithreading

Forking

class Monad m => Forkable m where

Monads with support for forking threads.

Methods

forkIO :: m () -> m ThreadId

Generalization of forkIO.

forkOS :: m () -> m ThreadId

Generalization of forkOS.

Instances

Forkable IO

Forkable m => Forkable (MaybeT () m)

Forkable m => Forkable (ContT () m)

Forkable m => Forkable (StateT () s m)

Forkable m => Forkable (EitherT () e m)

(Applicative m, Forkable m) => Forkable (ChoiceT r i m)

Exceptions

class HasExceptions m where

Monads with exception support.

Associated Types

type Exception m

The exception type.

Methods

raise :: Exception m -> m a

Raise an exception.

try :: m a -> m (Either (Exception m) a)

Run computation catching exceptions.

Instances

HasExceptions IO

HasExceptions Maybe

HasExceptions (Either e)

HasExceptions (MaybeT r m)

HasExceptions (EitherT r e m)

bracket :: (HasExceptions m, Monad m) => m res -> (res -> m b) -> (res -> m a) -> m a

Get a resource, run a computation, then release the resource, even if an exception is raised:

 bracket acquire release use

Please note that this function behaves slightly different from the usual E.bracket. If both the user and the releaser throw an exception, the user exception is significant.

bracket_ :: (HasExceptions m, Monad m) => m a -> m b -> m c -> m c

Initialize, then run, then clean up safely, even if an exception is raised:

 bracket_ init cleanup run

Please note that this function behaves slightly different from the usual E.bracket_. If both the user and the releaser throw an exception, the user exception is significant.

catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m a

Catch exceptions using an exception handler.

finally :: (HasExceptions m, Monad m) => m a -> m b -> m a

Run a final computation regardless of whether an exception was raised.

forbid :: (Exception (t m) ~ (), HasExceptions (t m), Monad m, Monad (t m), MonadTrans t) => m Bool -> t m ()

Fail (in the sense of the given transformer), if the given underlying computation returns True.

handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m a

Catch exceptions using an exception handler (flip catch).

raiseUnless :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()

Throw given exception, if the given computation returns False.

raiseWhen :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()

Throw given exception, if the given computation returns True.

require :: (Exception (t m) ~ (), HasExceptions (t m), Monad m, Monad (t m), MonadTrans t) => m Bool -> t m ()

Fail (in the sense of the given transformer), if the given underlying computation returns False.

Functor lifting

class LiftFunctor t where

Type class for lifting functor computations.

Associated Types

type InnerFunctor t :: * -> *

Inner functor.

Methods

liftF :: Monad m => m (InnerFunctor t a) -> t m a

Unwrap inner functor.

Instances

LiftFunctor (MaybeT r)

LiftFunctor (EitherT r e)

LiftFunctor (ChoiceT r i)

State

Reading

class Readable m where

Monads with environment (reader monads).

Associated Types

type StateOf m

Environment type of m.

Methods

get :: m (StateOf m)

Get the current state.

Instances

(Monad m, Readable m) => Readable (IdentityT m)

Readable (ReaderT e m)

(Monad m, Readable m) => Readable (MaybeT r m)

(Monad m, Readable m) => Readable (ContT r m)

Readable (StateT r s m)

(Monad m, Readable m) => Readable (EitherT r e m)

(Monad m, Readable m) => Readable (ChoiceT r i m)

getField :: (Functor m, Readable m) => (StateOf m -> a) -> m a

Get a certain field.

Writing

class Stateful m where

Stateful monads, i.e. having a modifyable environment (stateful monads).

Minimal complete definition: putLazy.

Methods

put :: StateOf m -> m ()

Set the current state and force it.

putLazy :: StateOf m -> m ()

Set the current state, but don't force it.

Instances

(Monad m, Stateful m) => Stateful (IdentityT m)

(Monad m, Stateful m) => Stateful (MaybeT r m)

(Monad m, Stateful m) => Stateful (ContT r m)

Stateful (StateT r s m)

(Monad m, Stateful m) => Stateful (EitherT r e m)

(Monad m, Stateful m) => Stateful (ChoiceT r i m)

modify :: (Monad m, Readable m, Stateful m) => (StateOf m -> StateOf m) -> m ()

Apply a function to the current state.

modifyField :: (Monad m, Readable m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()

Get a field and modify the state.

modifyFieldLazy :: (Monad m, Readable m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()

Get a field and modify the state. Lazy version.

modifyLazy :: (Monad m, Readable m, Stateful m) => (StateOf m -> StateOf m) -> m ()

Apply a function to the current state. Lazy version.

Logging support (writers)

class Writable m w where

Monads with support for logging. Traditionally these are called *writer monads*.

Methods

tell :: w -> m ()

Log a value.

Instances

(Functor m, Monoid w) => Writable (MaybeT (r, w) m) w

Alternative m => Writable (MaybeT r m) r

(Functor m, Monoid w) => Writable (ContT (r, w) m) w

Alternative m => Writable (ContT r m) r

(Functor m, Monoid w) => Writable (StateT (r, w) s m) w

Alternative m => Writable (StateT r s m) r

(Functor m, Monoid w) => Writable (EitherT (r, w) e m) w

Alternative m => Writable (EitherT r e m) r