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 (ContT r m)

Applicative m => Abortable (MaybeT r m)

Applicative m => Abortable (ChoiceT r i m)

Applicative m => Abortable (EitherT r e m)

Applicative m => Abortable (StateT r s 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 (ContT r m)

CallCC (MaybeT r m)

CallCC (EitherT r e m)

CallCC (StateT r s m)

data Label m a

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.

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), Transformer 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), Transformer t) => m Bool -> t m ()

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

Lifting

class Transformer t where

The monad transformer class. Lifting computations one level down the monad stack, or stated differently promoting a computation of the underlying monad to the transformer.

Methods

lift :: Monad m => m a -> t m a

Promote a monadic computation to the transformer.

Instances

Transformer IdT

Transformer (ContT r)

Transformer (MaybeT r)

Transformer (ChoiceT r i)

Transformer (EitherT r e)

Transformer (StateT r s)

class LiftBase m where

Monads, which support lifting base monad computations.

Associated Types

type Base m :: * -> *

Base monad of m.

Methods

base :: Base m a -> m a

Promote a base monad computation.

Instances

LiftBase []

LiftBase IO

LiftBase Maybe

LiftBase Id

LiftBase ((->) r)

LiftBase (ST s)

(LiftBase m, Monad m) => LiftBase (IdT m)

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

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

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

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

(LiftBase m, Monad m) => LiftBase (StateT r s m)

io :: (LiftBase m, Base m ~ IO) => Base m a -> m a

Handy alias for lifting IO computations.

Running

class Runnable t r m a where

Every monad transformer t that supports transforming t m a to m a can be an instance of this class.

Associated Types

type Argument t r m a

Arguments needed to run.

Methods

runT :: Argument t r m a -> t m a -> m r

Run the transformer.

Instances

Runnable IdT r m r

Runnable (ContT r) r m a

Runnable (MaybeT r) r m a

Runnable (EitherT r e) r m a

Runnable (StateT r s) r m a

State

class Stateful m where

Stateful monads.

Minimal complete definition: StateOf, get and putLazy.

Associated Types

type StateOf m

State type of m.

Methods

get :: m (StateOf m)

Get the current state.

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 (IdT m)

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

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

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

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

Stateful (StateT r s m)

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

Get a certain field.

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

Apply a function to the current state.

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

Get a field and modify the state.

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

Get a field and modify the state. Lazy version.

modifyLazy :: (Monad 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 (ContT (r, w) m) w

Alternative m => Writable (ContT r m) r

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

Alternative m => Writable (MaybeT r m) r

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

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

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

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