Control.Super.Monad.Functions

Collection of the ported monad-based functions for supermonads. For a more detailed description of these functions refer to the Monad module.

Most functions are generalized to suite the setting of supermonads better.

This module is thought as a replacement for the Control.Monad module.

Control.Monad replacements

Basic supermonad functions

mapM :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> m b) -> [a] -> n [b]

Map the given function on each element of the list and collect the results.

mapM_ :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> m b) -> [a] -> n ()

mapM ignoring the result.

forM :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => [a] -> (a -> m b) -> n [b]

flipped version of mapM.

forM_ :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => [a] -> (a -> m b) -> n ()

forM ignoring the result.

sequence :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => [m b] -> n [b]

Execute all computations in the list in order and returns the list of results.

sequence_ :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => [m b] -> n ()

sequence ignoring the result.

(=<<) :: (Bind m n p, BindCts m n p) => (a -> n b) -> m a -> p b infixr 1

Same as >>=, but with the arguments interchanged.

(>=>) :: (Bind m n p, BindCts m n p) => (a -> m b) -> (b -> n c) -> a -> p c infixr 1

Left-to-right Kleisli composition.

(<=<) :: (Bind m n p, BindCts m n p) => (b -> n c) -> (a -> m b) -> a -> p c infixr 1

Right-to-left Kleisli composition.

forever :: (Applicative m n n, ApplicativeCts m n n) => m a -> n b

Execute the given computation repeatedly forever.

void :: Functor f => f a -> f ()

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int '()':

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

voidM :: (Bind m n n, BindCts m n n, Return n, ReturnCts n) => m a -> n ()

Ignore the result of a computation, but allow morphing the computational type.

Generalizations of list functions

join :: (Bind m n p, BindCts m n p) => m (n a) -> p a

Monadic join operation.

filterM :: (Bind m n n, BindCts m n n, Return n, ReturnCts n) => (a -> m Bool) -> [a] -> n [a]

Like filter but with a monadic predicate and result.

mapAndUnzipM :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> m (b, c)) -> [a] -> n ([b], [c])

Map a given monadic function on the list and the unzip the results.

zipWithM :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> b -> m c) -> [a] -> [b] -> n [c]

Zip together two list using a monadic function.

zipWithM_ :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> b -> m c) -> [a] -> [b] -> n ()

Same as zipWithM, but ignores the results.

foldM :: (Foldable t, Return m, ReturnCts m, Bind m n m, BindCts m n m) => (b -> a -> n b) -> b -> t a -> m b

Fold the given foldable using a monadic function. See foldl.

foldM_ :: (Foldable t, Return m, ReturnCts m, Bind m n m, BindCts m n m) => (b -> a -> n b) -> b -> t a -> m ()

Same as foldM, but ignores the result.

replicateM :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => Int -> m a -> n [a]

Repeats the given monadic operation for the given amount of times and returns the accumulated results.

replicateM_ :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => Int -> m a -> n ()

Same as replicateM, but ignores the results.

Conditional execution of monadic expressions

when :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => Bool -> m () -> n ()

When the condition is true do the given action.

unless :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => Bool -> m () -> n ()

When the condition is false do the given action.

Monadic lifting operators

liftM :: Functor m => (a -> b) -> m a -> m b

Make arguments and result of a pure function monadic.

liftM' :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> b) -> m a -> n b

Make arguments and result of a pure function monadic with allowed morphing

liftM2 :: (Bind m n p, BindCts m n p) => (a -> b -> c) -> m a -> n b -> p c

Make arguments and result of a pure function monadic.

liftM3 :: (Bind m q q, BindCts m q q, Bind n p q, BindCts n p q) => (a -> b -> c -> d) -> m a -> n b -> p c -> q d

Make arguments and result of a pure function monadic.

ap :: (Bind m n p, BindCts m n p) => m (a -> b) -> n a -> p b

Make the resulting function a monadic function.

Strict monadic functions

(<$!>) :: (Return n, ReturnCts n, Bind m n n, BindCts m n n) => (a -> b) -> m a -> n b infixl 4

Strict version of <$>.

Additional generalized supermonad functions

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

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

Convert from a Maybe Int to a Maybe String using show:

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

Convert from an Either Int Int to an Either Int String using show:

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

Double each element of a list:

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

Apply even to the second element of a pair:

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

(<$) :: Functor f => forall a b. a -> f b -> f a infixl 4

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.

Addition due to RebindableSyntax

ifThenElse :: Bool -> a -> a -> a

Standard implementation of if-then-else. Necessary because we are going to use RebindableSyntax together with this prelude.

Functions based on applicatives

liftA3 :: (Applicative m n p, ApplicativeCts m n p, Applicative p p q, ApplicativeCts p p q) => (a -> b -> c -> d) -> m a -> n b -> p c -> q d

Make arguments and result of a pure function applicative.

liftA2 :: (Applicative m n p, ApplicativeCts m n p) => (a -> b -> c) -> m a -> n b -> p c

Make arguments and result of a pure function applicative.

liftA :: (Return m, ReturnCts m, Applicative m m n, ApplicativeCts m m n) => (a -> b) -> m a -> n b

Lift a function to actions. Does what fmap does with applicative operations.

voidA :: (Applicative m n n, ApplicativeCts m n n, Return n, ReturnCts n) => m a -> n ()

Ignore the result of a computation, but allow morphing the computational type.

(<**>) :: (Applicative m n p, ApplicativeCts m n p) => m a -> n (a -> b) -> p b

A variant of <*> with the arguments reversed.

mapA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> m b) -> [a] -> n [b]

Applicative version of mapM

mapA_ :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> m b) -> [a] -> n ()

mapA ignoring the result.

forA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => [a] -> (a -> m b) -> n [b]

flipped version of mapA.

forA_ :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => [a] -> (a -> m b) -> n ()

forA ignoring the result.

filterA :: (Applicative m n n, ApplicativeCts m n n, Return n, ReturnCts n) => (a -> m Bool) -> [a] -> n [a]

Like filterM but with an applicative predicate and result.

sequenceA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => [m a] -> n [a]

Specialization of the Traversable variant for list and applicatives.

sequenceA_ :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => [m a] -> n ()

sequenceA ignoring the result.

traverse :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> m b) -> [a] -> n [b]

Specialization of the Traversable variant for list and applicatives.

zipWithA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> b -> m c) -> [a] -> [b] -> n [c]

Like zipWithM but with an applicative predicate and result.

zipWithA_ :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> b -> m c) -> [a] -> [b] -> n ()

Like zipWithM_ but with an applicative predicate and result.

mapAndUnzipA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => (a -> m (b, c)) -> [a] -> n ([b], [c])

Like mapAndUnzipM but with an applicative predicate and result.

replicateA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => Int -> m a -> n [a]

Like replicateM but with applicatves.

replicateA_ :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => Int -> m a -> n ()

Like replicateA, but discards the result.

whenA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => Bool -> m () -> n ()

When the condition is true do the given action.

unlessA :: (Return n, ReturnCts n, Applicative m n n, ApplicativeCts m n n) => Bool -> m () -> n ()

When the condition is false do the given action.