Algebra.Applicative

A module describing applicative functors

Documentation

module Algebra.Functor

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

Methods

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

Instances

Applicative []

Applicative IO

Applicative Maybe

Applicative Tree

Applicative Interleave

Applicative Id

Applicative Strict

Applicative ((->) a)

Applicative (Either a)

Monoid w => Applicative ((,) w)

(Monoid k, Ord k) => Applicative (Map k)

Monoid a => Applicative (Const a)

Applicative f => Applicative (Backwards f)

Applicative (Zip [])

Applicative (Zip Tree)

Applicative m => Applicative (MaybeT m)

Applicative m => Applicative (TreeT m)

Applicative m => Applicative (ListT m)

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

(Applicative f, Applicative g) => Applicative (:.: f g)

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

Monad m => Applicative (StateT s m)

Monad m => Applicative (ReaderT r m)

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

Applicative m => Applicative (ContT r m)

Applicative m => Applicative (EitherT e m)

(Ring t, Monad m) => Applicative (ProbT t m)

(Monoid w, Monad m) => Applicative (WriterAccT w acc m)

(Monoid w, Monad m) => Applicative (RWST r w s m)

newtype Zip f a

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

Constructors

Zip

Fields

deZip :: f a

Instances

Unit (Zip [])

Unit (Zip Tree)

Traversable f => Traversable (Zip f)

Foldable f => Foldable (Zip f)

Applicative (Zip [])

Applicative (Zip Tree)

Functor f => Functor (Zip f)

(Applicative (Zip f), Monoid a) => Monoid (Zip f a)

(Applicative (Zip f), Semigroup a) => Semigroup (Zip f a)

newtype Backwards f a

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

Constructors

Backwards

Fields

forwards :: f a

Instances

ConcreteMonad Backwards

MonadTrans Backwards

MonadFuture m (Backwards m)

Unit f => Unit (Backwards f)

MonadFix m => MonadFix (Backwards m)

MonadFix m => Monad (Backwards m)

Applicative f => Applicative (Backwards f)

Functor f => Functor (Backwards f)

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

Semiring (f a) => Semiring (Backwards f a)

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

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

c'zip :: Constraint (f a) -> Constraint (Zip f a)

c'backwards :: Constraint (f a) -> Constraint (Backwards f a)

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

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

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

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

between :: Applicative f => f b -> f c -> f a -> f a

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

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

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

liftA4 :: Applicative f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e

forever :: Applicative f => f a -> f b

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

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