Control.Monad.Finish.Class

Monad type class for short-cicuiting computation.

Documentation

class Monad μ => MonadFinish f μ | μ -> f where

Class of monads that support short-circuiting.

Minimal complete definition

finish

Methods

finish :: f -> μ α

Short-circuit the computation with the provided value.

    finish f >>= rest = finish f

Instances

MonadFinish f μ => MonadFinish f (ListT μ)

Methods

finish :: f -> ListT μ α

MonadFinish f μ => MonadFinish f (MaybeT μ)

Methods

finish :: f -> MaybeT μ α

(MonadFinish f μ, Monoid w) => MonadFinish f (WriterT w μ)

Methods

finish :: f -> WriterT w μ α

(MonadFinish f μ, Monoid w) => MonadFinish f (WriterT w μ)

Methods

finish :: f -> WriterT w μ α

MonadFinish f μ => MonadFinish f (StateT s μ)

Methods

finish :: f -> StateT s μ α

MonadFinish f μ => MonadFinish f (StateT s μ)

Methods

finish :: f -> StateT s μ α

MonadFinish f μ => MonadFinish f (AbortT e μ)

Methods

finish :: f -> AbortT e μ α

MonadFinish f μ => MonadFinish f (ExceptT e μ)

Methods

finish :: f -> ExceptT e μ α

(MonadFinish f μ, Error e) => MonadFinish f (ErrorT e μ)

Methods

finish :: f -> ErrorT e μ α

MonadFinish f μ => MonadFinish f (IdentityT * μ)

Methods

finish :: f -> IdentityT * μ α

Monad μ => MonadFinish f (FinishT f μ)

Methods

finish :: f -> FinishT f μ α

MonadFinish f μ => MonadFinish f (ReaderT * r μ)

Methods

finish :: f -> ReaderT * r μ α

MonadFinish f μ => MonadFinish f (ContT * r μ)

Methods

finish :: f -> ContT * r μ α

(MonadFinish f μ, Monoid w) => MonadFinish f (RWST r w s μ)

Methods

finish :: f -> RWST r w s μ α

(MonadFinish f μ, Monoid w) => MonadFinish f (RWST r w s μ)

Methods

finish :: f -> RWST r w s μ α

Orphan instances

MonadRWS r w s μ => MonadRWS r w s (FinishT f μ)

MonadReader r μ => MonadReader r (FinishT f μ)

Methods

ask :: FinishT f μ r

local :: (r -> r) -> FinishT f μ a -> FinishT f μ a

reader :: (r -> a) -> FinishT f μ a

MonadState s μ => MonadState s (FinishT f μ)

Methods

get :: FinishT f μ s

put :: s -> FinishT f μ ()

state :: (s -> (a, s)) -> FinishT f μ a

MonadWriter w μ => MonadWriter w (FinishT f μ)

Methods

writer :: (a, w) -> FinishT f μ a

tell :: w -> FinishT f μ ()

listen :: FinishT f μ a -> FinishT f μ (a, w)

pass :: FinishT f μ (a, w -> w) -> FinishT f μ a

MonadError e μ => MonadError e (FinishT f μ)

Methods

throwError :: e -> FinishT f μ a

catchError :: FinishT f μ a -> (e -> FinishT f μ a) -> FinishT f μ a

MonadCont μ => MonadCont (FinishT f μ)

Methods

callCC :: ((a -> FinishT f μ b) -> FinishT f μ a) -> FinishT f μ a