Control.Cond

A convenient set of useful conditional operators.

Simple conditional operators

if' :: Bool -> a -> a -> a

A simple conditional function.

(??) :: a -> a -> Bool -> a

if' with the Bool argument at the end (infixr 1).

bool :: a -> a -> Bool -> a

A catamorphism (aka fold) for the Bool type. This is analogous to foldr, maybe, and either. The first argument is the false case, the second argument is the true case, and the last argument is the predicate value.

Lisp-style conditional operators

cond :: [(Bool, a)] -> a

Lisp-style conditionals. If no conditions match, then a runtime exception is thrown. Here's a trivial example:

   signum x = cond [(x > 0     , 1 )
                   ,(x < 0     , -1)
                   ,(otherwise , 0 )]

condPlus :: MonadPlus m => [(Bool, a)] -> m a

Lisp-style conditionals generalized over MonadPlus. If no conditions match, then the result is mzero. This is a safer variant of cond.

Here's a highly contrived example using fromMaybe:

   signum x = fromMaybe 0 . condPlus $ [(x > 0, 1 ) 
                                       ,(x < 0, -1)]

Alternatively, you could use the <| operator from Hoare's ternary conditional choice operator, like so:

   signum x = 0 <| condPlus [(x > 0, 1 ) 
                            ,(x < 0, -1)]

Conditional operator on categories

(?.) :: Category cat => Bool -> cat a a -> cat a a

Conditional composition. If the predicate is False, id is returned instead of the second argument. This function, for example, can be used to conditionally add functions to a composition chain.

Conditional operator on monoids

(?<>) :: Monoid a => Bool -> a -> a

Conditional monoid operator. If the predicate is False, the second argument is replaced with mempty. The fixity of this operator is one level higher than <>.

It can also be used to chain multiple predicates together, like this:

 even (length ls) ?<> not (null ls) ?<> ls

Conditional operator on functions

select :: (a -> Bool) -> (a -> b) -> (a -> b) -> a -> b

Composes a predicate function and 2 functions into a single function. The first function is called when the predicate yields True, the second when the predicate yields False.

Note that after importing Control.Monad.Instances, select becomes a special case of ifM.

C-style ternary conditional

(?) :: Bool -> (Bool -> a) -> a

An operator that allows you to write C-style ternary conditionals of the form:

 p ? t ?? f

Note that parentheses are required in order to chain sequences of conditionals together. This is probably a good thing.

Hoare's conditional choice operator

The following operators form a ternary conditional of the form

 t <| p |> f

These operators chain with right associative fixity. This allows chaining of conditions, where the result of the expression is the value to the left of the first predicate that succeeds.

For more information see http://zenzike.com/posts/2011-08-01-the-conditional-choice-operator

(|>) :: Bool -> a -> Maybe a

right bracket of the conditional choice operator. If the predicate is False, returns Nothing, otherwise it returns Just the right-hand argument.

(<|) :: a -> Maybe a -> a

left bracket of the conditional choice operator. This is equivalent to fromMaybe

Unicode variants

Intended to resemble the notation used in Tony Hoare's Unified Theories of Programming.

(⊳) :: Bool -> a -> Maybe a

Unicode rebinding of <|.

(⊲) :: a -> Maybe a -> a

Unicode rebinding of |>.

Lifted conditional and boolean operators

ifM :: Monad m => m Bool -> m a -> m a -> m a

if' lifted to Monad. Unlike liftM3 if', this is short-circuiting in the monad, such that only the predicate action and one of the remaining argument actions are executed.

(<||>) :: Monad m => m Bool -> m Bool -> m Bool

Lifted boolean or. Unlike liftM2 (||), This function is short-circuiting in the monad. Fixity is the same as || (infixr 2).

(<&&>) :: Monad m => m Bool -> m Bool -> m Bool

Lifted boolean and. Unlike liftM2 (&&), this function is short-circuiting in the monad. Fixity is the same as && (infxr 3).

notM :: Monad m => m Bool -> m Bool

Lifted boolean negation.

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

cond lifted to Monad. If no conditions match, a runtime exception is thrown.

condPlusM :: MonadPlus m => [(m Bool, m a)] -> m a

condPlus lifted to Monad. If no conditions match, then mzero is returned.

guardM :: MonadPlus m => m Bool -> m ()

a variant of guard with a monadic predicate.

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

a variant of when with a monadic predicate.

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

a variant of unless with a monadic predicate.