Documentation

Binary bind.

Monadic guard.

Monadic if-then-else.

ifNotM mc = ifM (not $ mc)

Lazy monadic conjunction.

Lazy monadic disjunction.

Lazy monadic disjunction with Either truth values. Returns the last error message if all fail.

Lazy monadic disjunction with accumulation of errors in a monoid. Errors are discarded if we succeed.

Generalized version of traverse_ :: Applicative m => (a -> m ()) -> [a] -> m () Executes effects and collects results in left-to-right order. Works best with left-associative monoids.

Note that there is an alternative

mapM' f t = foldr mappend mempty $ mapM f t

that collects results in right-to-left order (effects still left-to-right). It might be preferable for right associative monoids.

Generalized version of for_ :: Applicative m => [a] -> (a -> m ()) -> m ()

A monadic version of mapMaybe :: (a -> Maybe b) -> [a] -> [b].

A version of mapMaybeM with a computation for the input list.

The for version of mapMaybeM.

The for version of mapMaybeMM.

A monadic version of dropWhile :: (a -> Bool) -> [a] -> [a].

A monadic version of dropWhileEnd :: (a -> Bool) -> [a] -> m [a]. Effects happen starting at the end of the list until p becomes false.

A `monadic' version of @partition :: (a -> Bool) -> [a] -> ([a],[a])

Translates Maybe to MonadPlus.

Generalises the catMaybes function from lists to an arbitrary MonadPlus.

Branch over elements of a monadic Foldable data structure.

Finally for the Error class. Errors in the finally part take precedence over prior errors.

Try a computation, return Nothing if an Error occurs.

Run a command, catch the exception and return it.

Like guard, but raise given error when condition fails.

Bracket without failure. Typically used to preserve state.

Restore state after computation.

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

The reverse of when.

Monads that also support choice and failure.

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

>>> (*2) <$> [1,2,3]
[2,4,6]

>>> even <$> (2,2)
(2,True)

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Using ApplicativeDo: 'fs <*> as' can be understood as the do expression

do f <- fs
   a <- as
   pure (f a)

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Using ApplicativeDo: 'a <$ bs' can be understood as the do expression

do bs
   pure a

with an inferred Functor constraint.