Control.Monad.Constrained

A module for constrained monads. This module is intended to be imported with the -XRebindableSyntax extension turned on: everything from the Prelude (that doesn't conflict with the new Functor, Applicative, etc) is reexported, so these type classes can be used the same way that the Prelude classes are used.

Basic Classes

class Functor f where

This is the same class as Functor from the Prelude. Most of the functions here are simply rewritten versions of those, with one difference: types can indicate which types they can contain. This allows Set to be made into a monad, as well as some other exotic types. (but, to be fair, Set is kind of the poster child for this technique).

The way that types indicate what they can contain is with the Suitable associated type.

The default implementation is for types which conform to the Prelude's Functor. The way to make a standard Functor conform is by indicating that it has no constraints. For instance, for []:

instance Functor [] where
  fmap = map
  (<$) = (Prelude.<$)

Monomorphic types can also conform, using GADT aliases. For instance, if you create an alias for IntSet of kind * -> *:

data IntSet a where
  IntSet :: IntSet.IntSet -> IntSet Int

It can be made to conform to Functor like so:

instance Functor IntSet where
  type Suitable IntSet a = a ~ Int
  fmap f (IntSet xs) = IntSet (IntSet.map f xs)
  x <$ xs = if null xs then empty else pure x

It can also be made conform to Foldable, etc. This type is provided in Control.Monad.Constrained.IntSet.

Minimal complete definition

fmap

Associated Types

type Suitable f a :: Constraint

Indicate which types can be contained by f. For instance, Set conforms like so:

instance Functor Set where
    type Suitable Set a = Ord a
    fmap = Set.map
    x <$ xs = if Set.null xs then Set.empty else Set.singleton x

Methods

fmap :: Suitable f b => (a -> b) -> f a -> f b

Maps a function over a functor

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

Replace all values in the input with a default value.

Instances

Functor []

Associated Types

type Suitable ([] :: * -> *) a :: Constraint

Methods

fmap :: Suitable [] b => (a -> b) -> [a] -> [b]

(<$) :: Suitable [] a => a -> [b] -> [a]

Functor Maybe

Associated Types

type Suitable (Maybe :: * -> *) a :: Constraint

Methods

fmap :: Suitable Maybe b => (a -> b) -> Maybe a -> Maybe b

(<$) :: Suitable Maybe a => a -> Maybe b -> Maybe a

Functor IO

Associated Types

type Suitable (IO :: * -> *) a :: Constraint

Methods

fmap :: Suitable IO b => (a -> b) -> IO a -> IO b

(<$) :: Suitable IO a => a -> IO b -> IO a

Functor Identity

Associated Types

type Suitable (Identity :: * -> *) a :: Constraint

Methods

fmap :: Suitable Identity b => (a -> b) -> Identity a -> Identity b

(<$) :: Suitable Identity a => a -> Identity b -> Identity a

Functor ZipList

Associated Types

type Suitable (ZipList :: * -> *) a :: Constraint

Methods

fmap :: Suitable ZipList b => (a -> b) -> ZipList a -> ZipList b

(<$) :: Suitable ZipList a => a -> ZipList b -> ZipList a

Functor IntMap

Associated Types

type Suitable (IntMap :: * -> *) a :: Constraint

Methods

fmap :: Suitable IntMap b => (a -> b) -> IntMap a -> IntMap b

(<$) :: Suitable IntMap a => a -> IntMap b -> IntMap a

Functor Tree

Associated Types

type Suitable (Tree :: * -> *) a :: Constraint

Methods

fmap :: Suitable Tree b => (a -> b) -> Tree a -> Tree b

(<$) :: Suitable Tree a => a -> Tree b -> Tree a

Functor Seq

Associated Types

type Suitable (Seq :: * -> *) a :: Constraint

Methods

fmap :: Suitable Seq b => (a -> b) -> Seq a -> Seq b

(<$) :: Suitable Seq a => a -> Seq b -> Seq a

Functor Set

Associated Types

type Suitable (Set :: * -> *) a :: Constraint

Methods

fmap :: Suitable Set b => (a -> b) -> Set a -> Set b

(<$) :: Suitable Set a => a -> Set b -> Set a

Functor IntSet

Associated Types

type Suitable (IntSet :: * -> *) a :: Constraint

Methods

fmap :: Suitable IntSet b => (a -> b) -> IntSet a -> IntSet b

(<$) :: Suitable IntSet a => a -> IntSet b -> IntSet a

Functor ((->) a)

Associated Types

type Suitable ((->) a :: * -> *) a :: Constraint

Methods

fmap :: Suitable ((->) a) b => (a -> b) -> (a -> a) -> a -> b

(<$) :: Suitable ((->) a) a => a -> (a -> b) -> a -> a

Functor (Either e)

Associated Types

type Suitable (Either e :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Either e) b => (a -> b) -> Either e a -> Either e b

(<$) :: Suitable (Either e) a => a -> Either e b -> Either e a

Functor ((,) a)

Associated Types

type Suitable ((,) a :: * -> *) a :: Constraint

Methods

fmap :: Suitable ((,) a) b => (a -> b) -> (a, a) -> (a, b)

(<$) :: Suitable ((,) a) a => a -> (a, b) -> (a, a)

Functor (ST s)

Associated Types

type Suitable (ST s :: * -> *) a :: Constraint

Methods

fmap :: Suitable (ST s) b => (a -> b) -> ST s a -> ST s b

(<$) :: Suitable (ST s) a => a -> ST s b -> ST s a

Functor (Map a)

Associated Types

type Suitable (Map a :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Map a) b => (a -> b) -> Map a a -> Map a b

(<$) :: Suitable (Map a) a => a -> Map a b -> Map a a

Functor m => Functor (MaybeT m)

Associated Types

type Suitable (MaybeT m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (MaybeT m) b => (a -> b) -> MaybeT m a -> MaybeT m b

(<$) :: Suitable (MaybeT m) a => a -> MaybeT m b -> MaybeT m a

Functor (Const * a)

Associated Types

type Suitable (Const * a :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Const * a) b => (a -> b) -> Const * a a -> Const * a b

(<$) :: Suitable (Const * a) a => a -> Const * a b -> Const * a a

Functor m => Functor (IdentityT * m)

Associated Types

type Suitable (IdentityT * m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (IdentityT * m) b => (a -> b) -> IdentityT * m a -> IdentityT * m b

(<$) :: Suitable (IdentityT * m) a => a -> IdentityT * m b -> IdentityT * m a

Functor m => Functor (ExceptT e m)

Associated Types

type Suitable (ExceptT e m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (ExceptT e m) b => (a -> b) -> ExceptT e m a -> ExceptT e m b

(<$) :: Suitable (ExceptT e m) a => a -> ExceptT e m b -> ExceptT e m a

Functor m => Functor (StateT s m)

Associated Types

type Suitable (StateT s m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (StateT s m) b => (a -> b) -> StateT s m a -> StateT s m b

(<$) :: Suitable (StateT s m) a => a -> StateT s m b -> StateT s m a

Functor m => Functor (StateT s m)

Associated Types

type Suitable (StateT s m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (StateT s m) b => (a -> b) -> StateT s m a -> StateT s m b

(<$) :: Suitable (StateT s m) a => a -> StateT s m b -> StateT s m a

Functor m => Functor (WriterT s m)

Associated Types

type Suitable (WriterT s m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (WriterT s m) b => (a -> b) -> WriterT s m a -> WriterT s m b

(<$) :: Suitable (WriterT s m) a => a -> WriterT s m b -> WriterT s m a

(Functor f, Functor g) => Functor (Sum * f g)

Associated Types

type Suitable (Sum * f g :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Sum * f g) b => (a -> b) -> Sum * f g a -> Sum * f g b

(<$) :: Suitable (Sum * f g) a => a -> Sum * f g b -> Sum * f g a

(Functor f, Functor g) => Functor (Product * f g)

Associated Types

type Suitable (Product * f g :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Product * f g) b => (a -> b) -> Product * f g a -> Product * f g b

(<$) :: Suitable (Product * f g) a => a -> Product * f g b -> Product * f g a

Functor (ContT * r m)

Associated Types

type Suitable (ContT * r m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (ContT * r m) b => (a -> b) -> ContT * r m a -> ContT * r m b

(<$) :: Suitable (ContT * r m) a => a -> ContT * r m b -> ContT * r m a

Functor m => Functor (ReaderT * r m)

Associated Types

type Suitable (ReaderT * r m :: * -> *) a :: Constraint

Methods

fmap :: Suitable (ReaderT * r m) b => (a -> b) -> ReaderT * r m a -> ReaderT * r m b

(<$) :: Suitable (ReaderT * r m) a => a -> ReaderT * r m b -> ReaderT * r m a

(Functor f, Functor g) => Functor (Compose * * f g)

Associated Types

type Suitable (Compose * * f g :: * -> *) a :: Constraint

Methods

fmap :: Suitable (Compose * * f g) b => (a -> b) -> Compose * * f g a -> Compose * * f g b

(<$) :: Suitable (Compose * * f g) a => a -> Compose * * f g b -> Compose * * f g a

class (Applicative (Unconstrained f), Functor f) => Applicative f where

A functor with application.

This class is slightly different (although equivalent) to the class provided in the Prelude. This is to facilitate the lifting of functions to arbitrary numbers of arguments.

A minimal complete definition must include implementations of reflect and reify which convert to and from a law-abiding applicative, such that they form an isomorphism. Alternatively, you can conform to the standard prelude classes, and satisfy the following laws:

identity

pure id <*> v = v

composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

homomorphism

pure f <*> pure x = pure (f x)

interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = pure (const id) <*> u <*> v

• u <* v = pure const <*> u <*> v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

If f is also a Monad, it should satisfy

• pure = return

• (<*>) = ap

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

reflect, reify

Associated Types

type Unconstrained f :: * -> *

Methods

reflect :: f a -> Unconstrained f a

reify :: Suitable f a => Unconstrained f a -> f a

pure :: Suitable f a => a -> f a

Lift a value.

(<*>) :: Suitable f b => f (a -> b) -> f a -> f b infixl 4

Sequential application.

(*>) :: Suitable f b => f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

(<*) :: Suitable f a => f a -> f b -> f a infixl 4

Sequence actions, discarding the value of the second argument.

liftA2 :: Suitable f c => (a -> b -> c) -> f a -> f b -> f c

liftA3 :: Suitable f d => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

Instances

Applicative []

Associated Types

type Unconstrained ([] :: * -> *) :: * -> *

Methods

reflect :: [a] -> Unconstrained [] a

reify :: Suitable [] a => Unconstrained [] a -> [a]

pure :: Suitable [] a => a -> [a]

(<*>) :: Suitable [] b => [a -> b] -> [a] -> [b]

(*>) :: Suitable [] b => [a] -> [b] -> [b]

(<*) :: Suitable [] a => [a] -> [b] -> [a]

liftA2 :: Suitable [] c => (a -> b -> c) -> [a] -> [b] -> [c]

liftA3 :: Suitable [] d => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

Applicative Maybe

Associated Types

type Unconstrained (Maybe :: * -> *) :: * -> *

Methods

reflect :: Maybe a -> Unconstrained Maybe a

reify :: Suitable Maybe a => Unconstrained Maybe a -> Maybe a

pure :: Suitable Maybe a => a -> Maybe a

(<*>) :: Suitable Maybe b => Maybe (a -> b) -> Maybe a -> Maybe b

(*>) :: Suitable Maybe b => Maybe a -> Maybe b -> Maybe b

(<*) :: Suitable Maybe a => Maybe a -> Maybe b -> Maybe a

liftA2 :: Suitable Maybe c => (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

liftA3 :: Suitable Maybe d => (a -> b -> c -> d) -> Maybe a -> Maybe b -> Maybe c -> Maybe d

Applicative IO

Associated Types

type Unconstrained (IO :: * -> *) :: * -> *

Methods

reflect :: IO a -> Unconstrained IO a

reify :: Suitable IO a => Unconstrained IO a -> IO a

pure :: Suitable IO a => a -> IO a

(<*>) :: Suitable IO b => IO (a -> b) -> IO a -> IO b

(*>) :: Suitable IO b => IO a -> IO b -> IO b

(<*) :: Suitable IO a => IO a -> IO b -> IO a

liftA2 :: Suitable IO c => (a -> b -> c) -> IO a -> IO b -> IO c

liftA3 :: Suitable IO d => (a -> b -> c -> d) -> IO a -> IO b -> IO c -> IO d

Applicative Identity

Associated Types

type Unconstrained (Identity :: * -> *) :: * -> *

Methods

reflect :: Identity a -> Unconstrained Identity a

reify :: Suitable Identity a => Unconstrained Identity a -> Identity a

pure :: Suitable Identity a => a -> Identity a

(<*>) :: Suitable Identity b => Identity (a -> b) -> Identity a -> Identity b

(*>) :: Suitable Identity b => Identity a -> Identity b -> Identity b

(<*) :: Suitable Identity a => Identity a -> Identity b -> Identity a

liftA2 :: Suitable Identity c => (a -> b -> c) -> Identity a -> Identity b -> Identity c

liftA3 :: Suitable Identity d => (a -> b -> c -> d) -> Identity a -> Identity b -> Identity c -> Identity d

Applicative ZipList

Associated Types

type Unconstrained (ZipList :: * -> *) :: * -> *

Methods

reflect :: ZipList a -> Unconstrained ZipList a

reify :: Suitable ZipList a => Unconstrained ZipList a -> ZipList a

pure :: Suitable ZipList a => a -> ZipList a

(<*>) :: Suitable ZipList b => ZipList (a -> b) -> ZipList a -> ZipList b

(*>) :: Suitable ZipList b => ZipList a -> ZipList b -> ZipList b

(<*) :: Suitable ZipList a => ZipList a -> ZipList b -> ZipList a

liftA2 :: Suitable ZipList c => (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

liftA3 :: Suitable ZipList d => (a -> b -> c -> d) -> ZipList a -> ZipList b -> ZipList c -> ZipList d

Applicative Tree

Associated Types

type Unconstrained (Tree :: * -> *) :: * -> *

Methods

reflect :: Tree a -> Unconstrained Tree a

reify :: Suitable Tree a => Unconstrained Tree a -> Tree a

pure :: Suitable Tree a => a -> Tree a

(<*>) :: Suitable Tree b => Tree (a -> b) -> Tree a -> Tree b

(*>) :: Suitable Tree b => Tree a -> Tree b -> Tree b

(<*) :: Suitable Tree a => Tree a -> Tree b -> Tree a

liftA2 :: Suitable Tree c => (a -> b -> c) -> Tree a -> Tree b -> Tree c

liftA3 :: Suitable Tree d => (a -> b -> c -> d) -> Tree a -> Tree b -> Tree c -> Tree d

Applicative Seq

Associated Types

type Unconstrained (Seq :: * -> *) :: * -> *

Methods

reflect :: Seq a -> Unconstrained Seq a

reify :: Suitable Seq a => Unconstrained Seq a -> Seq a

pure :: Suitable Seq a => a -> Seq a

(<*>) :: Suitable Seq b => Seq (a -> b) -> Seq a -> Seq b

(*>) :: Suitable Seq b => Seq a -> Seq b -> Seq b

(<*) :: Suitable Seq a => Seq a -> Seq b -> Seq a

liftA2 :: Suitable Seq c => (a -> b -> c) -> Seq a -> Seq b -> Seq c

liftA3 :: Suitable Seq d => (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d

Applicative Set

Associated Types

type Unconstrained (Set :: * -> *) :: * -> *

Methods

reflect :: Set a -> Unconstrained Set a

reify :: Suitable Set a => Unconstrained Set a -> Set a

pure :: Suitable Set a => a -> Set a

(<*>) :: Suitable Set b => Set (a -> b) -> Set a -> Set b

(*>) :: Suitable Set b => Set a -> Set b -> Set b

(<*) :: Suitable Set a => Set a -> Set b -> Set a

liftA2 :: Suitable Set c => (a -> b -> c) -> Set a -> Set b -> Set c

liftA3 :: Suitable Set d => (a -> b -> c -> d) -> Set a -> Set b -> Set c -> Set d

Applicative IntSet

Associated Types

type Unconstrained (IntSet :: * -> *) :: * -> *

Methods

reflect :: IntSet a -> Unconstrained IntSet a

reify :: Suitable IntSet a => Unconstrained IntSet a -> IntSet a

pure :: Suitable IntSet a => a -> IntSet a

(<*>) :: Suitable IntSet b => IntSet (a -> b) -> IntSet a -> IntSet b

(*>) :: Suitable IntSet b => IntSet a -> IntSet b -> IntSet b

(<*) :: Suitable IntSet a => IntSet a -> IntSet b -> IntSet a

liftA2 :: Suitable IntSet c => (a -> b -> c) -> IntSet a -> IntSet b -> IntSet c

liftA3 :: Suitable IntSet d => (a -> b -> c -> d) -> IntSet a -> IntSet b -> IntSet c -> IntSet d

Applicative ((->) a)

Associated Types

type Unconstrained ((->) a :: * -> *) :: * -> *

Methods

reflect :: (a -> a) -> Unconstrained ((->) a) a

reify :: Suitable ((->) a) a => Unconstrained ((->) a) a -> a -> a

pure :: Suitable ((->) a) a => a -> a -> a

(<*>) :: Suitable ((->) a) b => (a -> a -> b) -> (a -> a) -> a -> b

(*>) :: Suitable ((->) a) b => (a -> a) -> (a -> b) -> a -> b

(<*) :: Suitable ((->) a) a => (a -> a) -> (a -> b) -> a -> a

liftA2 :: Suitable ((->) a) c => (a -> b -> c) -> (a -> a) -> (a -> b) -> a -> c

liftA3 :: Suitable ((->) a) d => (a -> b -> c -> d) -> (a -> a) -> (a -> b) -> (a -> c) -> a -> d

Applicative (Either a)

Associated Types

type Unconstrained (Either a :: * -> *) :: * -> *

Methods

reflect :: Either a a -> Unconstrained (Either a) a

reify :: Suitable (Either a) a => Unconstrained (Either a) a -> Either a a

pure :: Suitable (Either a) a => a -> Either a a

(<*>) :: Suitable (Either a) b => Either a (a -> b) -> Either a a -> Either a b

(*>) :: Suitable (Either a) b => Either a a -> Either a b -> Either a b

(<*) :: Suitable (Either a) a => Either a a -> Either a b -> Either a a

liftA2 :: Suitable (Either a) c => (a -> b -> c) -> Either a a -> Either a b -> Either a c

liftA3 :: Suitable (Either a) d => (a -> b -> c -> d) -> Either a a -> Either a b -> Either a c -> Either a d

Monoid a => Applicative ((,) a)

Associated Types

type Unconstrained ((,) a :: * -> *) :: * -> *

Methods

reflect :: (a, a) -> Unconstrained ((,) a) a

reify :: Suitable ((,) a) a => Unconstrained ((,) a) a -> (a, a)

pure :: Suitable ((,) a) a => a -> (a, a)

(<*>) :: Suitable ((,) a) b => (a, a -> b) -> (a, a) -> (a, b)

(*>) :: Suitable ((,) a) b => (a, a) -> (a, b) -> (a, b)

(<*) :: Suitable ((,) a) a => (a, a) -> (a, b) -> (a, a)

liftA2 :: Suitable ((,) a) c => (a -> b -> c) -> (a, a) -> (a, b) -> (a, c)

liftA3 :: Suitable ((,) a) d => (a -> b -> c -> d) -> (a, a) -> (a, b) -> (a, c) -> (a, d)

Applicative (ST s)

Associated Types

type Unconstrained (ST s :: * -> *) :: * -> *

Methods

reflect :: ST s a -> Unconstrained (ST s) a

reify :: Suitable (ST s) a => Unconstrained (ST s) a -> ST s a

pure :: Suitable (ST s) a => a -> ST s a

(<*>) :: Suitable (ST s) b => ST s (a -> b) -> ST s a -> ST s b

(*>) :: Suitable (ST s) b => ST s a -> ST s b -> ST s b

(<*) :: Suitable (ST s) a => ST s a -> ST s b -> ST s a

liftA2 :: Suitable (ST s) c => (a -> b -> c) -> ST s a -> ST s b -> ST s c

liftA3 :: Suitable (ST s) d => (a -> b -> c -> d) -> ST s a -> ST s b -> ST s c -> ST s d

(Monad (Unconstrained m), Monad m) => Applicative (MaybeT m)

Associated Types

type Unconstrained (MaybeT m :: * -> *) :: * -> *

Methods

reflect :: MaybeT m a -> Unconstrained (MaybeT m) a

reify :: Suitable (MaybeT m) a => Unconstrained (MaybeT m) a -> MaybeT m a

pure :: Suitable (MaybeT m) a => a -> MaybeT m a

(<*>) :: Suitable (MaybeT m) b => MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b

(*>) :: Suitable (MaybeT m) b => MaybeT m a -> MaybeT m b -> MaybeT m b

(<*) :: Suitable (MaybeT m) a => MaybeT m a -> MaybeT m b -> MaybeT m a

liftA2 :: Suitable (MaybeT m) c => (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c

liftA3 :: Suitable (MaybeT m) d => (a -> b -> c -> d) -> MaybeT m a -> MaybeT m b -> MaybeT m c -> MaybeT m d

Monoid a => Applicative (Const * a)

Associated Types

type Unconstrained (Const * a :: * -> *) :: * -> *

Methods

reflect :: Const * a a -> Unconstrained (Const * a) a

reify :: Suitable (Const * a) a => Unconstrained (Const * a) a -> Const * a a

pure :: Suitable (Const * a) a => a -> Const * a a

(<*>) :: Suitable (Const * a) b => Const * a (a -> b) -> Const * a a -> Const * a b

(*>) :: Suitable (Const * a) b => Const * a a -> Const * a b -> Const * a b

(<*) :: Suitable (Const * a) a => Const * a a -> Const * a b -> Const * a a

liftA2 :: Suitable (Const * a) c => (a -> b -> c) -> Const * a a -> Const * a b -> Const * a c

liftA3 :: Suitable (Const * a) d => (a -> b -> c -> d) -> Const * a a -> Const * a b -> Const * a c -> Const * a d

Applicative m => Applicative (IdentityT * m)

Associated Types

type Unconstrained (IdentityT * m :: * -> *) :: * -> *

Methods

reflect :: IdentityT * m a -> Unconstrained (IdentityT * m) a

reify :: Suitable (IdentityT * m) a => Unconstrained (IdentityT * m) a -> IdentityT * m a

pure :: Suitable (IdentityT * m) a => a -> IdentityT * m a

(<*>) :: Suitable (IdentityT * m) b => IdentityT * m (a -> b) -> IdentityT * m a -> IdentityT * m b

(*>) :: Suitable (IdentityT * m) b => IdentityT * m a -> IdentityT * m b -> IdentityT * m b

(<*) :: Suitable (IdentityT * m) a => IdentityT * m a -> IdentityT * m b -> IdentityT * m a

liftA2 :: Suitable (IdentityT * m) c => (a -> b -> c) -> IdentityT * m a -> IdentityT * m b -> IdentityT * m c

liftA3 :: Suitable (IdentityT * m) d => (a -> b -> c -> d) -> IdentityT * m a -> IdentityT * m b -> IdentityT * m c -> IdentityT * m d

(Monad m, Monad (Unconstrained m)) => Applicative (ExceptT e m)

Associated Types

type Unconstrained (ExceptT e m :: * -> *) :: * -> *

Methods

reflect :: ExceptT e m a -> Unconstrained (ExceptT e m) a

reify :: Suitable (ExceptT e m) a => Unconstrained (ExceptT e m) a -> ExceptT e m a

pure :: Suitable (ExceptT e m) a => a -> ExceptT e m a

(<*>) :: Suitable (ExceptT e m) b => ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b

(*>) :: Suitable (ExceptT e m) b => ExceptT e m a -> ExceptT e m b -> ExceptT e m b

(<*) :: Suitable (ExceptT e m) a => ExceptT e m a -> ExceptT e m b -> ExceptT e m a

liftA2 :: Suitable (ExceptT e m) c => (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c

liftA3 :: Suitable (ExceptT e m) d => (a -> b -> c -> d) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c -> ExceptT e m d

(Monad m, Monad (Unconstrained m)) => Applicative (StateT s m)

Associated Types

type Unconstrained (StateT s m :: * -> *) :: * -> *

Methods

reflect :: StateT s m a -> Unconstrained (StateT s m) a

reify :: Suitable (StateT s m) a => Unconstrained (StateT s m) a -> StateT s m a

pure :: Suitable (StateT s m) a => a -> StateT s m a

(<*>) :: Suitable (StateT s m) b => StateT s m (a -> b) -> StateT s m a -> StateT s m b

(*>) :: Suitable (StateT s m) b => StateT s m a -> StateT s m b -> StateT s m b

(<*) :: Suitable (StateT s m) a => StateT s m a -> StateT s m b -> StateT s m a

liftA2 :: Suitable (StateT s m) c => (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

liftA3 :: Suitable (StateT s m) d => (a -> b -> c -> d) -> StateT s m a -> StateT s m b -> StateT s m c -> StateT s m d

(Monad m, Monad (Unconstrained m)) => Applicative (StateT s m)

Associated Types

type Unconstrained (StateT s m :: * -> *) :: * -> *

Methods

reflect :: StateT s m a -> Unconstrained (StateT s m) a

reify :: Suitable (StateT s m) a => Unconstrained (StateT s m) a -> StateT s m a

pure :: Suitable (StateT s m) a => a -> StateT s m a

(<*>) :: Suitable (StateT s m) b => StateT s m (a -> b) -> StateT s m a -> StateT s m b

(*>) :: Suitable (StateT s m) b => StateT s m a -> StateT s m b -> StateT s m b

(<*) :: Suitable (StateT s m) a => StateT s m a -> StateT s m b -> StateT s m a

liftA2 :: Suitable (StateT s m) c => (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

liftA3 :: Suitable (StateT s m) d => (a -> b -> c -> d) -> StateT s m a -> StateT s m b -> StateT s m c -> StateT s m d

(Monad m, Monad (Unconstrained m)) => Applicative (WriterT s m)

Associated Types

type Unconstrained (WriterT s m :: * -> *) :: * -> *

Methods

reflect :: WriterT s m a -> Unconstrained (WriterT s m) a

reify :: Suitable (WriterT s m) a => Unconstrained (WriterT s m) a -> WriterT s m a

pure :: Suitable (WriterT s m) a => a -> WriterT s m a

(<*>) :: Suitable (WriterT s m) b => WriterT s m (a -> b) -> WriterT s m a -> WriterT s m b

(*>) :: Suitable (WriterT s m) b => WriterT s m a -> WriterT s m b -> WriterT s m b

(<*) :: Suitable (WriterT s m) a => WriterT s m a -> WriterT s m b -> WriterT s m a

liftA2 :: Suitable (WriterT s m) c => (a -> b -> c) -> WriterT s m a -> WriterT s m b -> WriterT s m c

liftA3 :: Suitable (WriterT s m) d => (a -> b -> c -> d) -> WriterT s m a -> WriterT s m b -> WriterT s m c -> WriterT s m d

(Applicative f, Applicative g) => Applicative (Product * f g)

Associated Types

type Unconstrained (Product * f g :: * -> *) :: * -> *

Methods

reflect :: Product * f g a -> Unconstrained (Product * f g) a

reify :: Suitable (Product * f g) a => Unconstrained (Product * f g) a -> Product * f g a

pure :: Suitable (Product * f g) a => a -> Product * f g a

(<*>) :: Suitable (Product * f g) b => Product * f g (a -> b) -> Product * f g a -> Product * f g b

(*>) :: Suitable (Product * f g) b => Product * f g a -> Product * f g b -> Product * f g b

(<*) :: Suitable (Product * f g) a => Product * f g a -> Product * f g b -> Product * f g a

liftA2 :: Suitable (Product * f g) c => (a -> b -> c) -> Product * f g a -> Product * f g b -> Product * f g c

liftA3 :: Suitable (Product * f g) d => (a -> b -> c -> d) -> Product * f g a -> Product * f g b -> Product * f g c -> Product * f g d

Applicative (ContT * r m)

Associated Types

type Unconstrained (ContT * r m :: * -> *) :: * -> *

Methods

reflect :: ContT * r m a -> Unconstrained (ContT * r m) a

reify :: Suitable (ContT * r m) a => Unconstrained (ContT * r m) a -> ContT * r m a

pure :: Suitable (ContT * r m) a => a -> ContT * r m a

(<*>) :: Suitable (ContT * r m) b => ContT * r m (a -> b) -> ContT * r m a -> ContT * r m b

(*>) :: Suitable (ContT * r m) b => ContT * r m a -> ContT * r m b -> ContT * r m b

(<*) :: Suitable (ContT * r m) a => ContT * r m a -> ContT * r m b -> ContT * r m a

liftA2 :: Suitable (ContT * r m) c => (a -> b -> c) -> ContT * r m a -> ContT * r m b -> ContT * r m c

liftA3 :: Suitable (ContT * r m) d => (a -> b -> c -> d) -> ContT * r m a -> ContT * r m b -> ContT * r m c -> ContT * r m d

Applicative m => Applicative (ReaderT * r m)

Associated Types

type Unconstrained (ReaderT * r m :: * -> *) :: * -> *

Methods

reflect :: ReaderT * r m a -> Unconstrained (ReaderT * r m) a

reify :: Suitable (ReaderT * r m) a => Unconstrained (ReaderT * r m) a -> ReaderT * r m a

pure :: Suitable (ReaderT * r m) a => a -> ReaderT * r m a

(<*>) :: Suitable (ReaderT * r m) b => ReaderT * r m (a -> b) -> ReaderT * r m a -> ReaderT * r m b

(*>) :: Suitable (ReaderT * r m) b => ReaderT * r m a -> ReaderT * r m b -> ReaderT * r m b

(<*) :: Suitable (ReaderT * r m) a => ReaderT * r m a -> ReaderT * r m b -> ReaderT * r m a

liftA2 :: Suitable (ReaderT * r m) c => (a -> b -> c) -> ReaderT * r m a -> ReaderT * r m b -> ReaderT * r m c

liftA3 :: Suitable (ReaderT * r m) d => (a -> b -> c -> d) -> ReaderT * r m a -> ReaderT * r m b -> ReaderT * r m c -> ReaderT * r m d

(Applicative f, Applicative g) => Applicative (Compose * * f g)

Associated Types

type Unconstrained (Compose * * f g :: * -> *) :: * -> *

Methods

reflect :: Compose * * f g a -> Unconstrained (Compose * * f g) a

reify :: Suitable (Compose * * f g) a => Unconstrained (Compose * * f g) a -> Compose * * f g a

pure :: Suitable (Compose * * f g) a => a -> Compose * * f g a

(<*>) :: Suitable (Compose * * f g) b => Compose * * f g (a -> b) -> Compose * * f g a -> Compose * * f g b

(*>) :: Suitable (Compose * * f g) b => Compose * * f g a -> Compose * * f g b -> Compose * * f g b

(<*) :: Suitable (Compose * * f g) a => Compose * * f g a -> Compose * * f g b -> Compose * * f g a

liftA2 :: Suitable (Compose * * f g) c => (a -> b -> c) -> Compose * * f g a -> Compose * * f g b -> Compose * * f g c

liftA3 :: Suitable (Compose * * f g) d => (a -> b -> c -> d) -> Compose * * f g a -> Compose * * f g b -> Compose * * f g c -> Compose * * f g d

class Applicative f => Monad f where

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following laws:

• return a >>= k  =  k a

• m >>= return  =  m

• m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

• pure = return

• (<*>) = ap

The above laws imply:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for lists, Maybe and IO defined in the "Prelude" satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: Suitable f b => f a -> (a -> f b) -> f b infixl 1

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

Instances

Monad []

Methods

(>>=) :: Suitable [] b => [a] -> (a -> [b]) -> [b]

Monad Maybe

Methods

(>>=) :: Suitable Maybe b => Maybe a -> (a -> Maybe b) -> Maybe b

Monad IO

Methods

(>>=) :: Suitable IO b => IO a -> (a -> IO b) -> IO b

Monad Identity

Methods

(>>=) :: Suitable Identity b => Identity a -> (a -> Identity b) -> Identity b

Monad Tree

Methods

(>>=) :: Suitable Tree b => Tree a -> (a -> Tree b) -> Tree b

Monad Seq

Methods

(>>=) :: Suitable Seq b => Seq a -> (a -> Seq b) -> Seq b

Monad Set

Methods

(>>=) :: Suitable Set b => Set a -> (a -> Set b) -> Set b

Monad IntSet

Methods

(>>=) :: Suitable IntSet b => IntSet a -> (a -> IntSet b) -> IntSet b

Monad ((->) a)

Methods

(>>=) :: Suitable ((->) a) b => (a -> a) -> (a -> a -> b) -> a -> b

Monad (Either a)

Methods

(>>=) :: Suitable (Either a) b => Either a a -> (a -> Either a b) -> Either a b

Monoid a => Monad ((,) a)

Methods

(>>=) :: Suitable ((,) a) b => (a, a) -> (a -> (a, b)) -> (a, b)

Monad (ST s)

Methods

(>>=) :: Suitable (ST s) b => ST s a -> (a -> ST s b) -> ST s b

(Monad m, Monad (Unconstrained m)) => Monad (MaybeT m)

Methods

(>>=) :: Suitable (MaybeT m) b => MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b

Monad m => Monad (IdentityT * m)

Methods

(>>=) :: Suitable (IdentityT * m) b => IdentityT * m a -> (a -> IdentityT * m b) -> IdentityT * m b

(Monad m, Monad (Unconstrained m)) => Monad (ExceptT e m)

Methods

(>>=) :: Suitable (ExceptT e m) b => ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b

(Monad m, Monad (Unconstrained m)) => Monad (StateT s m)

Methods

(>>=) :: Suitable (StateT s m) b => StateT s m a -> (a -> StateT s m b) -> StateT s m b

(Monad m, Monad (Unconstrained m)) => Monad (StateT s m)

Methods

(>>=) :: Suitable (StateT s m) b => StateT s m a -> (a -> StateT s m b) -> StateT s m b

(Monad m, Monad (Unconstrained m)) => Monad (WriterT s m)

Methods

(>>=) :: Suitable (WriterT s m) b => WriterT s m a -> (a -> WriterT s m b) -> WriterT s m b

(Monad f, Monad g) => Monad (Product * f g)

Methods

(>>=) :: Suitable (Product * f g) b => Product * f g a -> (a -> Product * f g b) -> Product * f g b

Monad (ContT * r m)

Methods

(>>=) :: Suitable (ContT * r m) b => ContT * r m a -> (a -> ContT * r m b) -> ContT * r m b

Monad m => Monad (ReaderT * r m)

Methods

(>>=) :: Suitable (ReaderT * r m) b => ReaderT * r m a -> (a -> ReaderT * r m b) -> ReaderT * r m b

class Applicative f => Alternative f where

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

• some v = (:) <$> v <*> many v

• many v = some v <|> pure []

Minimal complete definition

empty, (<|>)

Methods

empty :: Suitable f a => f a

The identity of <|>

(<|>) :: Suitable f a => f a -> f a -> f a infixl 3

An associative binary operation

some :: Suitable f [a] => f a -> f [a]

One or more.

many :: Suitable f [a] => f a -> f [a]

Zero or more.

Instances

Alternative []

Methods

empty :: Suitable [] a => [a]

(<|>) :: Suitable [] a => [a] -> [a] -> [a]

some :: Suitable [] [a] => [a] -> [[a]]

many :: Suitable [] [a] => [a] -> [[a]]

Alternative Maybe

Methods

empty :: Suitable Maybe a => Maybe a

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

some :: Suitable Maybe [a] => Maybe a -> Maybe [a]

many :: Suitable Maybe [a] => Maybe a -> Maybe [a]

Alternative IO

Methods

empty :: Suitable IO a => IO a

(<|>) :: Suitable IO a => IO a -> IO a -> IO a

some :: Suitable IO [a] => IO a -> IO [a]

many :: Suitable IO [a] => IO a -> IO [a]

Alternative Seq

Methods

empty :: Suitable Seq a => Seq a

(<|>) :: Suitable Seq a => Seq a -> Seq a -> Seq a

some :: Suitable Seq [a] => Seq a -> Seq [a]

many :: Suitable Seq [a] => Seq a -> Seq [a]

Alternative Set

Methods

empty :: Suitable Set a => Set a

(<|>) :: Suitable Set a => Set a -> Set a -> Set a

some :: Suitable Set [a] => Set a -> Set [a]

many :: Suitable Set [a] => Set a -> Set [a]

Alternative IntSet

Methods

empty :: Suitable IntSet a => IntSet a

(<|>) :: Suitable IntSet a => IntSet a -> IntSet a -> IntSet a

some :: Suitable IntSet [a] => IntSet a -> IntSet [a]

many :: Suitable IntSet [a] => IntSet a -> IntSet [a]

(Monad m, Monad (Unconstrained m)) => Alternative (MaybeT m)

Methods

empty :: Suitable (MaybeT m) a => MaybeT m a

(<|>) :: Suitable (MaybeT m) a => MaybeT m a -> MaybeT m a -> MaybeT m a

some :: Suitable (MaybeT m) [a] => MaybeT m a -> MaybeT m [a]

many :: Suitable (MaybeT m) [a] => MaybeT m a -> MaybeT m [a]

(Monad m, Monoid e, Monad (Unconstrained m)) => Alternative (ExceptT e m)

Methods

empty :: Suitable (ExceptT e m) a => ExceptT e m a

(<|>) :: Suitable (ExceptT e m) a => ExceptT e m a -> ExceptT e m a -> ExceptT e m a

some :: Suitable (ExceptT e m) [a] => ExceptT e m a -> ExceptT e m [a]

many :: Suitable (ExceptT e m) [a] => ExceptT e m a -> ExceptT e m [a]

(Monad m, Alternative m, Monad (Unconstrained m)) => Alternative (StateT s m)

Methods

empty :: Suitable (StateT s m) a => StateT s m a

(<|>) :: Suitable (StateT s m) a => StateT s m a -> StateT s m a -> StateT s m a

some :: Suitable (StateT s m) [a] => StateT s m a -> StateT s m [a]

many :: Suitable (StateT s m) [a] => StateT s m a -> StateT s m [a]

(Monad m, Alternative m, Monad (Unconstrained m)) => Alternative (StateT s m)

Methods

empty :: Suitable (StateT s m) a => StateT s m a

(<|>) :: Suitable (StateT s m) a => StateT s m a -> StateT s m a -> StateT s m a

some :: Suitable (StateT s m) [a] => StateT s m a -> StateT s m [a]

many :: Suitable (StateT s m) [a] => StateT s m a -> StateT s m [a]

(Alternative f, Alternative g) => Alternative (Product * f g)

Methods

empty :: Suitable (Product * f g) a => Product * f g a

(<|>) :: Suitable (Product * f g) a => Product * f g a -> Product * f g a -> Product * f g a

some :: Suitable (Product * f g) [a] => Product * f g a -> Product * f g [a]

many :: Suitable (Product * f g) [a] => Product * f g a -> Product * f g [a]

Alternative m => Alternative (ReaderT * r m)

Methods

empty :: Suitable (ReaderT * r m) a => ReaderT * r m a

(<|>) :: Suitable (ReaderT * r m) a => ReaderT * r m a -> ReaderT * r m a -> ReaderT * r m a

some :: Suitable (ReaderT * r m) [a] => ReaderT * r m a -> ReaderT * r m [a]

many :: Suitable (ReaderT * r m) [a] => ReaderT * r m a -> ReaderT * r m [a]

(Alternative f, Applicative g) => Alternative (Compose * * f g)

Methods

empty :: Suitable (Compose * * f g) a => Compose * * f g a

(<|>) :: Suitable (Compose * * f g) a => Compose * * f g a -> Compose * * f g a -> Compose * * f g a

some :: Suitable (Compose * * f g) [a] => Compose * * f g a -> Compose * * f g [a]

many :: Suitable (Compose * * f g) [a] => Compose * * f g a -> Compose * * f g [a]

class (Foldable t, Functor t) => Traversable t where

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality

t . traverse f = traverse (t . f) for every applicative transformation t

identity

traverse Identity = Identity

composition

traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality

t . sequenceA = sequenceA . fmap t for every applicative transformation t

identity

sequenceA . fmap Identity = Identity

composition

sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

• t (pure x) = pure x

• t (x <*> y) = t x <*> t y

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

• In the Functor instance, fmap should be equivalent to traversal with the identity applicative functor (fmapDefault).
• In the Foldable instance, foldMap should be equivalent to traversal with a constant applicative functor (foldMapDefault).

Minimal complete definition

traverse

Methods

traverse :: (Suitable t b, Applicative f, Suitable f (t b), Suitable f b) => (a -> f b) -> t a -> f (t b)

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

Instances

Traversable []

Methods

traverse :: (Suitable [] b, Applicative f, Suitable f [b], Suitable f b) => (a -> f b) -> [a] -> f [b]

Traversable Maybe

Methods

traverse :: (Suitable Maybe b, Applicative f, Suitable f (Maybe b), Suitable f b) => (a -> f b) -> Maybe a -> f (Maybe b)

Traversable Identity

Methods

traverse :: (Suitable Identity b, Applicative f, Suitable f (Identity b), Suitable f b) => (a -> f b) -> Identity a -> f (Identity b)

Traversable Tree

Methods

traverse :: (Suitable Tree b, Applicative f, Suitable f (Tree b), Suitable f b) => (a -> f b) -> Tree a -> f (Tree b)

Traversable (Either a)

Methods

traverse :: (Suitable (Either a) b, Applicative f, Suitable f (Either a b), Suitable f b) => (a -> f b) -> Either a a -> f (Either a b)

Traversable ((,) a)

Methods

traverse :: (Suitable ((,) a) b, Applicative f, Suitable f (a, b), Suitable f b) => (a -> f b) -> (a, a) -> f (a, b)

class Monad f => MonadFail f where

See here for more details.

Minimal complete definition

fail

Methods

fail :: Suitable f a => String -> f a

Called when a pattern match fails in do-notation.

Instances

MonadFail []

Methods

fail :: Suitable [] a => String -> [a]

MonadFail Maybe

Methods

fail :: Suitable Maybe a => String -> Maybe a

MonadFail IO

Methods

fail :: Suitable IO a => String -> IO a

MonadFail Seq

Methods

fail :: Suitable Seq a => String -> Seq a

MonadFail Set

Methods

fail :: Suitable Set a => String -> Set a

IsString a => MonadFail (Either a)

Methods

fail :: Suitable (Either a) a => String -> Either a a

(Monad m, Monad (Unconstrained m)) => MonadFail (MaybeT m)

Methods

fail :: Suitable (MaybeT m) a => String -> MaybeT m a

MonadFail m => MonadFail (IdentityT * m)

Methods

fail :: Suitable (IdentityT * m) a => String -> IdentityT * m a

(Monad m, IsString e, Monad (Unconstrained m)) => MonadFail (ExceptT e m)

Methods

fail :: Suitable (ExceptT e m) a => String -> ExceptT e m a

MonadFail m => MonadFail (ReaderT * r m)

Methods

fail :: Suitable (ReaderT * r m) a => String -> ReaderT * r m a

Unconstrained applicative stuff

ap :: (Monad f, Suitable f a) => (a -> f a) -> Ap f a -> f a

A definition of reify that uses monadic operations. This is actually the instance of applicative for codensity in disguise.

Useful functions

guard :: (Alternative f, Suitable f ()) => Bool -> f ()

guard b is pure () if b is True, and empty if b is False.

ensure :: (Alternative f, Suitable f a) => Bool -> f a -> f a

ensure b x is x if b is True, and empty if b is False.

(<**>) :: (Applicative f, Suitable f b) => f a -> f (a -> b) -> f b infixl 4

A variant of <*> with the arguments reversed.

(<$>) :: (Functor f, Suitable f b) => (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)

(=<<) :: (Monad f, Suitable f b) => (a -> f b) -> f a -> f b infixr 1

A flipped version of >>=

(<=<) :: (Monad f, Suitable f c) => (b -> f c) -> (a -> f b) -> a -> f c infixr 1

Right-to-left Kleisli composition of monads. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: (Monad f, Suitable f c) => (a -> f b) -> (b -> f c) -> a -> f c infixl 1

Left-to-right Kleisli composition of monads.

foldM :: (Foldable t, Monad m, Suitable m b) => (b -> a -> m b) -> b -> t a -> m b

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

traverse_ :: (Applicative f, Foldable t, Suitable f ()) => (a -> f b) -> t a -> f ()

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse.

sequenceA :: (Applicative f, Suitable t a, Suitable f (t a), Traversable t, Suitable f a) => t (f a) -> f (t a)

Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.

sequenceA_ :: (Foldable t, Applicative f, Suitable f ()) => t (f a) -> f ()

Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequenceA.

mapAccumL :: (Traversable t, Suitable t c) => (a -> b -> (a, c)) -> a -> t b -> (a, t c)

The mapAccumL function behaves like a combination of fmap and foldl; it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

replicateM :: (Applicative m, Suitable m [a]) => Int -> m a -> m [a]

replicateM n act performs the action n times, gathering the results.

void :: (Functor f, Suitable 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:

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

forever :: (Applicative f, Suitable f b) => f a -> f b

forever act repeats the action infinitely.

for_ :: (Foldable t, Applicative f, Suitable f ()) => t a -> (a -> f b) -> f ()

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for.

>>> for_ [1..4] print
1
2
3
4

join :: (Monad f, Suitable f a) => f (f a) -> f a

Collapse one monadic layer.

Syntax

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

Function to which the if ... then ... else syntax desugars to

(>>) :: (Applicative f, Suitable f b) => f a -> f b -> f b infixl 1

Sequence two actions, discarding the result of the first. Alias for (*>).

return :: (Applicative f, Suitable f a) => a -> f a

Alias for pure.