Clean.Applicative

A module describing applicative functors

Documentation

module Clean.Functor

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

Methods

(<*>) :: f (a -> b) -> f a -> f b

Instances

Applicative []

Applicative IO

Applicative Tree

Applicative Interleave

Applicative Id

Applicative ZipTree

Applicative ZipList

Applicative ((->) a)

Applicative (Either a)

Monoid w => Applicative ((,) w)

Applicative (Const a)

Applicative f => Applicative (Backwards f)

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

Monad m => Applicative (ContT r m)

(Monoid w, Monad m) => Applicative (WriterT w m)

Monad m => Applicative (ReaderT r m)

Monad m => Applicative (StateT s m)

Monad m => Applicative (Kleisli m a)

newtype ZipList a

A wrapper type for lists with zipping Applicative instances, such that ZipList [f1,...,fn] <*> ZipList [x1,...,xn] == ZipList [f1 x1,...,fn xn]

Constructors

ZipList

Fields

getZipList :: [a]

Instances

Unit ZipList

Applicative ZipList

Functor ZipList

Foldable ZipList

Traversable ZipList

Monoid a => Monoid (ZipList a)

Semigroup a => Semigroup (ZipList a)

newtype ZipTree a

The Tree equivalent to ZipList

Constructors

ZipTree (Tree a)

Instances

Unit ZipTree

Applicative ZipTree

Functor ZipTree

Foldable ZipTree

Traversable ZipTree

newtype Backwards f a

A wrapper for applicative functors with actions executed in the reverse order

Constructors

Backwards

Fields

forwards :: f a

Instances

MonadTrans Backwards

Unit f => Unit (Backwards f)

MonadFix m => Monad (Backwards m)

Applicative f => Applicative (Backwards f)

Functor f => Functor (Backwards f)

Ring (f a) => Ring (Backwards f a)

Monoid (f a) => Monoid (Backwards f a)

Semigroup (f a) => Semigroup (Backwards f a)

(*>) :: Applicative f => f a1 -> f a -> f a

(<*) :: Applicative f => f a1 -> f a -> f a1

ap :: Applicative f => f (a -> b) -> f a -> f b

liftA :: Functor f => (a -> b) -> f a -> f b

liftA2 :: Applicative f => (a1 -> a -> b) -> f a1 -> f a -> f b

liftA3 :: Applicative f => (a2 -> a1 -> a -> b) -> f a2 -> f a1 -> f a -> f b

liftA4 :: Applicative f => (a3 -> a2 -> a1 -> a -> b) -> f a3 -> f a2 -> f a1 -> f a -> f b

plusA :: (Semigroup b, Applicative f) => f b -> f b -> f b

zeroA :: (Unit f, Monoid a) => f a