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

- 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
- ncondM :: Monad m => [(m Bool, 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 ()Source

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

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

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

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

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

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

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

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

Chainable anaphoric when. Takes a maybe value.

if the value is Just x then execute ` action x `

, then return ` True `

. otherwise return ` False `

.

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

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

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

Anaphoric if where the test is in Monad m.

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

Contrapositive of whenM, if not x then do y

unless-else chain.

monadic unless-else chain

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

IO lifted ` && `

IO lifted ` || `

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

unless the left side is true, perform the right action

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

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

composition of ` >>= `

and ` >>? `

composition of ` >>= `

and ` >>=? `

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

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

Negation of `whileM`

: execute an action so long as the boolean
returns false.

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

Strict version of `return`

because usually we don't need that
extra thunk.