Control.Monad.IfElse

IfElse-0.85: Anaphoric and miscellaneous useful control-flow

Safe Haskell | None
Language | Haskell98

Control.Monad.IfElse

Description

Library for control flow inside of monads with anaphoric variants on if and when and a C-like "switch" function.

Information:

`Author`
  Jeff Heard
`Copyright`
  2008 Jeff Heard
`License`
  BSD
`Version`
  1.0
`Status`
  Alpha

Synopsis

- whenM :: Monad m => m Bool -> m () -> m ()
- cond :: Monad m => [(Bool, m ())] -> m ()
- condM :: Monad m => [(m Bool, m ())] -> m ()
- awhen :: Monad m => Maybe a -> (a -> m ()) -> m ()
- awhenM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- acond :: Monad m => [(Maybe a, a -> m ())] -> m ()
- aif :: Monad m => Maybe a -> (a -> m b) -> m b -> m b
- aifM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b
- unlessM :: Monad m => m Bool -> m () -> m ()
- ncond :: Monad m => [(Bool, m ())] -> m ()
- ncondM :: Monad m => [(m Bool, m ())] -> m ()
- (&&^) :: Monad m => m Bool -> m Bool -> m Bool
- (||^) :: Monad m => m Bool -> m Bool -> m Bool
- (>>?) :: Applicative f => Bool -> f () -> f ()
- (>>!) :: Applicative f => Bool -> f () -> f ()
- (>>=>>!) :: Monad m => m Bool -> m () -> m ()
- (>>=?) :: Monad m => Maybe a -> (a -> m ()) -> m ()
- (>>=>>?) :: Monad m => m Bool -> m () -> m ()
- (>>=>>=?) :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- whileM :: Monad m => m Bool -> m () -> m ()
- untilM :: Monad m => m Bool -> m () -> m ()
- return' :: Monad m => a -> m a
- returning :: Monad m => (a -> m b) -> a -> m a
- maybeMP :: MonadPlus m => Maybe a -> m a

# Documentation

whenM :: Monad m => m Bool -> m () -> m () #

A if with no else for unit returning thunks. Returns the value of the test.

cond :: Monad m => [(Bool, m ())] -> m () #

Like a switch statement, and less cluttered than if else if

    cond [ (t1,a1), (t2,a2), ... ]

condM :: Monad m => [(m Bool, m ())] -> m () #

Like a switch statement, and less cluttered than if else if

    condM [ (t1,a1), (t2,a2), ... ]

awhen :: Monad m => Maybe a -> (a -> m ()) -> m () #

Chainable anaphoric when. Takes a maybe value.

if the value is Just x then execute `action x` , then return `True` . otherwise return `False` .

awhenM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () #

Chainable anaphoric whenM.

acond :: Monad m => [(Maybe a, a -> m ())] -> m () #

Anaphoric when-else chain. Like a switch statement, but less cluttered

aif :: Monad m => Maybe a -> (a -> m b) -> m b -> m b #

Anaphoric if.

aifM :: Monad m => m (Maybe a) -> (a -> m b) -> m b -> m b #

Anaphoric if where the test is in Monad m.

unlessM :: Monad m => m Bool -> m () -> m () #

Contrapositive of whenM, if not x then do y

ncond :: Monad m => [(Bool, m ())] -> m () #

unless-else chain.

ncondM :: Monad m => [(m Bool, m ())] -> m () #

monadic unless-else chain

(&&^) :: Monad m => m Bool -> m Bool -> m Bool #

IO lifted `&&`

(||^) :: Monad m => m Bool -> m Bool -> m Bool #

IO lifted `||`

(>>?) :: Applicative f => Bool -> f () -> f () infixl 1 #

Conditionally do the right action based on the truth value of the left expression

(>>!) :: Applicative f => Bool -> f () -> f () infixl 1 #

unless the left side is true, perform the right action

(>>=>>!) :: Monad m => m Bool -> m () -> m () infixl 1 #

unless the (monadic) left side is true, perform the right action

(>>=?) :: Monad m => Maybe a -> (a -> m ()) -> m () infixl 1 #

Bind the result of the last expression in an anaphoric when.

(>>=>>?) :: Monad m => m Bool -> m () -> m () infixl 1 #

composition of `>>=` and `>>?`

(>>=>>=?) :: Monad m => m (Maybe a) -> (a -> m ()) -> m () infixl 1 #

composition of `>>=` and `>>=?`

whileM :: Monad m => m Bool -> m () -> m () #

Execute a monadic action so long as a monadic boolean returns true.

untilM :: Monad m => m Bool -> m () -> m () #

Negation of `whileM`: execute an action so long as the boolean returns false.

return' :: Monad m => a -> m a #

Strict version of `return` because usually we don't need that extra thunk.

returning :: Monad m => (a -> m b) -> a -> m a infixr 8 #

Take an action and make it into a side-effecting `return`. Because I seem to keep running into `m ()` and the like.

maybeMP :: MonadPlus m => Maybe a -> m a #

This conversion is common enough to make a name for.