Diagrams.Prelude

A module to re-export most of the functionality of the diagrams core and standard library.

Diagrams library

Exports from this library for working with diagrams.

module Diagrams

Convenience re-exports from other packages

For working with default values. Diagrams also exports with, an alias for def.

module Data.Default.Class

For representing and operating on colors.

module Data.Colour

A large list of color names.

module Data.Colour.Names

Specify your own colours.

module Data.Colour.SRGB

Semigroups and monoids show up all over the place, so things from Data.Semigroup and Data.Monoid often come in handy.

module Data.Semigroup

For computing with vectors.

module Linear.Vector

For computing with points and vectors.

module Linear.Affine

For computing with dot products and norm.

module Linear.Metric

For working with Active (i.e. animated) things.

module Data.Active

Most of the lens package. The following functions are not exported from lens because they either conflict with diagrams or may conflict with other libraries:

• at
• contains
• .>
• <.>
• index
• indices
• none
• coerce
• indexed
• inside
• levels
• ...
• children
• transform
• outside
• argument
• beside
• singular

module Control.Lens

class Functor f => Applicative (f :: * -> *) where

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

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 = (id <$ u) <*> v

• u <* v = liftA2 const u v

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

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

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

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a

Lift a value.

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

Sequential application.

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

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

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative []

Since: 2.1

Methods

pure :: a -> [a]

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

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

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

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

Applicative Maybe

Since: 2.1

Methods

pure :: a -> Maybe a

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

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

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

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

Applicative IO

Since: 2.1

Methods

pure :: a -> IO a

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

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

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

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

Applicative Par1

Since: 4.9.0.0

Methods

pure :: a -> Par1 a

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

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

(*>) :: Par1 a -> Par1 b -> Par1 b

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

Applicative Q

Methods

pure :: a -> Q a

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

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

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

Applicative Active

Methods

pure :: a -> Active a

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

liftA2 :: (a -> b -> c) -> Active a -> Active b -> Active c

(*>) :: Active a -> Active b -> Active b

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

Applicative Duration

Methods

pure :: a -> Duration a

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

liftA2 :: (a -> b -> c) -> Duration a -> Duration b -> Duration c

(*>) :: Duration a -> Duration b -> Duration b

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

Applicative P

Since: 4.5.0.0

Methods

pure :: a -> P a

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

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

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

Applicative Complex

Since: 4.9.0.0

Methods

pure :: a -> Complex a

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

liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

(*>) :: Complex a -> Complex b -> Complex b

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

Applicative Min

Since: 4.9.0.0

Methods

pure :: a -> Min a

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

liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c

(*>) :: Min a -> Min b -> Min b

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

Applicative Max

Since: 4.9.0.0

Methods

pure :: a -> Max a

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

liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c

(*>) :: Max a -> Max b -> Max b

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

Applicative First

Since: 4.9.0.0

Methods

pure :: a -> First a

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

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

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

Applicative Last

Since: 4.9.0.0

Methods

pure :: a -> Last a

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

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

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

Applicative Option

Since: 4.9.0.0

Methods

pure :: a -> Option a

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

liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c

(*>) :: Option a -> Option b -> Option b

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

Applicative NonEmpty

Since: 4.9.0.0

Methods

pure :: a -> NonEmpty a

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

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

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

Applicative ZipList

f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN

ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: 2.1

Methods

pure :: a -> ZipList a

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

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

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

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

Applicative Identity

Since: 4.8.0.0

Methods

pure :: a -> Identity a

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

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

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

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

Applicative STM

Since: 4.8.0.0

Methods

pure :: a -> STM a

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

liftA2 :: (a -> b -> c) -> STM a -> STM b -> STM c

(*>) :: STM a -> STM b -> STM b

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

Applicative Dual

Since: 4.8.0.0

Methods

pure :: a -> Dual a

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

liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

(*>) :: Dual a -> Dual b -> Dual b

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

Applicative Sum

Since: 4.8.0.0

Methods

pure :: a -> Sum a

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

liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

(*>) :: Sum a -> Sum b -> Sum b

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

Applicative Product

Since: 4.8.0.0

Methods

pure :: a -> Product a

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

liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c

(*>) :: Product a -> Product b -> Product b

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

Applicative First

Methods

pure :: a -> First a

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

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

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

Applicative Last

Methods

pure :: a -> Last a

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

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

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

Applicative ReadPrec

Since: 4.6.0.0

Methods

pure :: a -> ReadPrec a

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

liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c

(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b

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

Applicative ReadP

Since: 4.6.0.0

Methods

pure :: a -> ReadP a

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

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

(*>) :: ReadP a -> ReadP b -> ReadP b

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

Applicative PutM

Methods

pure :: a -> PutM a

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

liftA2 :: (a -> b -> c) -> PutM a -> PutM b -> PutM c

(*>) :: PutM a -> PutM b -> PutM b

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

Applicative Get

Methods

pure :: a -> Get a

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

liftA2 :: (a -> b -> c) -> Get a -> Get b -> Get c

(*>) :: Get a -> Get b -> Get b

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

Applicative RGB

Methods

pure :: a -> RGB a

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

liftA2 :: (a -> b -> c) -> RGB a -> RGB b -> RGB c

(*>) :: RGB a -> RGB b -> RGB b

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

Applicative Tree

Methods

pure :: a -> Tree a

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

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

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

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

Applicative Seq

Methods

pure :: a -> Seq a

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

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

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

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

Applicative Interval

Methods

pure :: a -> Interval a

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

liftA2 :: (a -> b -> c) -> Interval a -> Interval b -> Interval c

(*>) :: Interval a -> Interval b -> Interval b

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

Applicative Vector

Methods

pure :: a -> Vector a

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

liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

(*>) :: Vector a -> Vector b -> Vector b

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

Applicative Plucker

Methods

pure :: a -> Plucker a

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

liftA2 :: (a -> b -> c) -> Plucker a -> Plucker b -> Plucker c

(*>) :: Plucker a -> Plucker b -> Plucker b

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

Applicative Quaternion

Methods

pure :: a -> Quaternion a

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

liftA2 :: (a -> b -> c) -> Quaternion a -> Quaternion b -> Quaternion c

(*>) :: Quaternion a -> Quaternion b -> Quaternion b

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

Applicative V0

Methods

pure :: a -> V0 a

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

liftA2 :: (a -> b -> c) -> V0 a -> V0 b -> V0 c

(*>) :: V0 a -> V0 b -> V0 b

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

Applicative V4

Methods

pure :: a -> V4 a

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

liftA2 :: (a -> b -> c) -> V4 a -> V4 b -> V4 c

(*>) :: V4 a -> V4 b -> V4 b

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

Applicative V3

Methods

pure :: a -> V3 a

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

liftA2 :: (a -> b -> c) -> V3 a -> V3 b -> V3 c

(*>) :: V3 a -> V3 b -> V3 b

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

Applicative V2

Methods

pure :: a -> V2 a

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

liftA2 :: (a -> b -> c) -> V2 a -> V2 b -> V2 c

(*>) :: V2 a -> V2 b -> V2 b

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

Applicative V1

Methods

pure :: a -> V1 a

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

liftA2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c

(*>) :: V1 a -> V1 b -> V1 b

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

Applicative ReadM

Methods

pure :: a -> ReadM a

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

liftA2 :: (a -> b -> c) -> ReadM a -> ReadM b -> ReadM c

(*>) :: ReadM a -> ReadM b -> ReadM b

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

Applicative Parser

Methods

pure :: a -> Parser a

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

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

(*>) :: Parser a -> Parser b -> Parser b

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

Applicative ParserM

Methods

pure :: a -> ParserM a

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

liftA2 :: (a -> b -> c) -> ParserM a -> ParserM b -> ParserM c

(*>) :: ParserM a -> ParserM b -> ParserM b

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

Applicative ParserResult

Methods

pure :: a -> ParserResult a

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

liftA2 :: (a -> b -> c) -> ParserResult a -> ParserResult b -> ParserResult c

(*>) :: ParserResult a -> ParserResult b -> ParserResult b

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

Applicative Array

Methods

pure :: a -> Array a

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

liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c

(*>) :: Array a -> Array b -> Array b

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

Applicative Id

Methods

pure :: a -> Id a

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

liftA2 :: (a -> b -> c) -> Id a -> Id b -> Id c

(*>) :: Id a -> Id b -> Id b

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

Applicative Box

Methods

pure :: a -> Box a

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

liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c

(*>) :: Box a -> Box b -> Box b

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

Applicative Stream

Methods

pure :: a -> Stream a

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

liftA2 :: (a -> b -> c) -> Stream a -> Stream b -> Stream c

(*>) :: Stream a -> Stream b -> Stream b

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

Applicative Angle

Methods

pure :: a -> Angle a

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

liftA2 :: (a -> b -> c) -> Angle a -> Angle b -> Angle c

(*>) :: Angle a -> Angle b -> Angle b

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

Applicative (Either e)

Since: 3.0

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative (U1 *)

Since: 4.9.0.0

Methods

pure :: a -> U1 * a

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

liftA2 :: (a -> b -> c) -> U1 * a -> U1 * b -> U1 * c

(*>) :: U1 * a -> U1 * b -> U1 * b

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

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: 2.1

Methods

pure :: a -> (a, a)

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

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

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

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

Representable f => Applicative (Co f)

Methods

pure :: a -> Co f a

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

liftA2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c

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

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

Applicative (ST s)

Since: 4.4.0.0

Methods

pure :: a -> ST s a

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

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

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

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

Monad m => Applicative (WrappedMonad m)

Since: 2.1

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Applicative (ArrowMonad a)

Since: 4.6.0.0

Methods

pure :: a -> ArrowMonad a a

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

liftA2 :: (a -> b -> c) -> ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a c

(*>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b

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

Applicative (Proxy *)

Since: 4.7.0.0

Methods

pure :: a -> Proxy * a

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

liftA2 :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c

(*>) :: Proxy * a -> Proxy * b -> Proxy * b

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

Applicative (State s)

Methods

pure :: a -> State s a

(<*>) :: State s (a -> b) -> State s a -> State s b

liftA2 :: (a -> b -> c) -> State s a -> State s b -> State s c

(*>) :: State s a -> State s b -> State s b

(<*) :: State s a -> State s b -> State s a

Applicative (Measured n)

Methods

pure :: a -> Measured n a

(<*>) :: Measured n (a -> b) -> Measured n a -> Measured n b

liftA2 :: (a -> b -> c) -> Measured n a -> Measured n b -> Measured n c

(*>) :: Measured n a -> Measured n b -> Measured n b

(<*) :: Measured n a -> Measured n b -> Measured n a

Applicative f => Applicative (Point f)

Methods

pure :: a -> Point f a

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

liftA2 :: (a -> b -> c) -> Point f a -> Point f b -> Point f c

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

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

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

Methods

pure :: a -> MaybeT m a

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

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

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

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

Monad m => Applicative (CatchT m)

Methods

pure :: a -> CatchT m a

(<*>) :: CatchT m (a -> b) -> CatchT m a -> CatchT m b

liftA2 :: (a -> b -> c) -> CatchT m a -> CatchT m b -> CatchT m c

(*>) :: CatchT m a -> CatchT m b -> CatchT m b

(<*) :: CatchT m a -> CatchT m b -> CatchT m a

Alternative f => Applicative (Cofree f)

Methods

pure :: a -> Cofree f a

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

liftA2 :: (a -> b -> c) -> Cofree f a -> Cofree f b -> Cofree f c

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

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

Functor f => Applicative (Free f)

Methods

pure :: a -> Free f a

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

liftA2 :: (a -> b -> c) -> Free f a -> Free f b -> Free f c

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

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

Monad m => Applicative (IterT m)

Methods

pure :: a -> IterT m a

(<*>) :: IterT m (a -> b) -> IterT m a -> IterT m b

liftA2 :: (a -> b -> c) -> IterT m a -> IterT m b -> IterT m c

(*>) :: IterT m a -> IterT m b -> IterT m b

(<*) :: IterT m a -> IterT m b -> IterT m a

Applicative (AltF f)

Methods

pure :: a -> AltF f a

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

liftA2 :: (a -> b -> c) -> AltF f a -> AltF f b -> AltF f c

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

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

Applicative (Alt f)

Methods

pure :: a -> Alt f a

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

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

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

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

Applicative f => Applicative (Yoneda f)

Methods

pure :: a -> Yoneda f a

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

liftA2 :: (a -> b -> c) -> Yoneda f a -> Yoneda f b -> Yoneda f c

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

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

Applicative (ReifiedGetter s)

Methods

pure :: a -> ReifiedGetter s a

(<*>) :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b

liftA2 :: (a -> b -> c) -> ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s c

(*>) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b

(<*) :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a

Applicative (ReifiedFold s)

Methods

pure :: a -> ReifiedFold s a

(<*>) :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b

liftA2 :: (a -> b -> c) -> ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s c

(*>) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b

(<*) :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a

Applicative f => Applicative (Indexing f)

Methods

pure :: a -> Indexing f a

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

liftA2 :: (a -> b -> c) -> Indexing f a -> Indexing f b -> Indexing f c

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

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

Applicative f => Applicative (Indexing64 f)

Methods

pure :: a -> Indexing64 f a

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

liftA2 :: (a -> b -> c) -> Indexing64 f a -> Indexing64 f b -> Indexing64 f c

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

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

Applicative (Inf p)

Methods

pure :: a -> Inf p a

(<*>) :: Inf p (a -> b) -> Inf p a -> Inf p b

liftA2 :: (a -> b -> c) -> Inf p a -> Inf p b -> Inf p c

(*>) :: Inf p a -> Inf p b -> Inf p b

(<*) :: Inf p a -> Inf p b -> Inf p a

Applicative m => Applicative (ListT m)

Methods

pure :: a -> ListT m a

(<*>) :: ListT m (a -> b) -> ListT m a -> ListT m b

liftA2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c

(*>) :: ListT m a -> ListT m b -> ListT m b

(<*) :: ListT m a -> ListT m b -> ListT m a

(Applicative (Rep p), Representable p) => Applicative (Prep p)

Methods

pure :: a -> Prep p a

(<*>) :: Prep p (a -> b) -> Prep p a -> Prep p b

liftA2 :: (a -> b -> c) -> Prep p a -> Prep p b -> Prep p c

(*>) :: Prep p a -> Prep p b -> Prep p b

(<*) :: Prep p a -> Prep p b -> Prep p a

Applicative f => Applicative (WrappedApplicative f)

Methods

pure :: a -> WrappedApplicative f a

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

liftA2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c

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

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

Apply f => Applicative (MaybeApply f)

Methods

pure :: a -> MaybeApply f a

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

liftA2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c

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

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

Applicative f => Applicative (Rec1 * f)

Since: 4.9.0.0

Methods

pure :: a -> Rec1 * f a

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

liftA2 :: (a -> b -> c) -> Rec1 * f a -> Rec1 * f b -> Rec1 * f c

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

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

Arrow a => Applicative (WrappedArrow a b)

Since: 2.1

Methods

pure :: a -> WrappedArrow a b a

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

liftA2 :: (a -> b -> c) -> WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b c

(*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b

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

Monoid m => Applicative (Const * m)

Since: 2.0.1

Methods

pure :: a -> Const * m a

(<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b

liftA2 :: (a -> b -> c) -> Const * m a -> Const * m b -> Const * m c

(*>) :: Const * m a -> Const * m b -> Const * m b

(<*) :: Const * m a -> Const * m b -> Const * m a

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

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

liftA2 :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c

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

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

Biapplicative p => Applicative (Join * p)

Methods

pure :: a -> Join * p a

(<*>) :: Join * p (a -> b) -> Join * p a -> Join * p b

liftA2 :: (a -> b -> c) -> Join * p a -> Join * p b -> Join * p c

(*>) :: Join * p a -> Join * p b -> Join * p b

(<*) :: Join * p a -> Join * p b -> Join * p a

Biapplicative p => Applicative (Fix * p)

Methods

pure :: a -> Fix * p a

(<*>) :: Fix * p (a -> b) -> Fix * p a -> Fix * p b

liftA2 :: (a -> b -> c) -> Fix * p a -> Fix * p b -> Fix * p c

(*>) :: Fix * p a -> Fix * p b -> Fix * p b

(<*) :: Fix * p a -> Fix * p b -> Fix * p a

Applicative w => Applicative (TracedT m w)

Methods

pure :: a -> TracedT m w a

(<*>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b

liftA2 :: (a -> b -> c) -> TracedT m w a -> TracedT m w b -> TracedT m w c

(*>) :: TracedT m w a -> TracedT m w b -> TracedT m w b

(<*) :: TracedT m w a -> TracedT m w b -> TracedT m w a

Applicative m => Applicative (IdentityT * m)

Methods

pure :: a -> IdentityT * m a

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

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

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

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

(Applicative f, Monad f) => Applicative (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Methods

pure :: a -> WhenMissing f x a

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

liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c

(*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b

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

Applicative (Query v n)

Methods

pure :: a -> Query v n a

(<*>) :: Query v n (a -> b) -> Query v n a -> Query v n b

liftA2 :: (a -> b -> c) -> Query v n a -> Query v n b -> Query v n c

(*>) :: Query v n a -> Query v n b -> Query v n b

(<*) :: Query v n a -> Query v n b -> Query v n a

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

Methods

pure :: a -> ExceptT e m a

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

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

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

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

(Functor f, Monad m) => Applicative (FreeT f m)

Methods

pure :: a -> FreeT f m a

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

liftA2 :: (a -> b -> c) -> FreeT f m a -> FreeT f m b -> FreeT f m c

(*>) :: FreeT f m a -> FreeT f m b -> FreeT f m b

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

(Alternative f, Applicative w) => Applicative (CofreeT f w)

Methods

pure :: a -> CofreeT f w a

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

liftA2 :: (a -> b -> c) -> CofreeT f w a -> CofreeT f w b -> CofreeT f w c

(*>) :: CofreeT f w a -> CofreeT f w b -> CofreeT f w b

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

Applicative g => Applicative (ApF f g)

Methods

pure :: a -> ApF f g a

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

liftA2 :: (a -> b -> c) -> ApF f g a -> ApF f g b -> ApF f g c

(*>) :: ApF f g a -> ApF f g b -> ApF f g b

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

Applicative g => Applicative (ApT f g)

Methods

pure :: a -> ApT f g a

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

liftA2 :: (a -> b -> c) -> ApT f g a -> ApT f g b -> ApT f g c

(*>) :: ApT f g a -> ApT f g b -> ApT f g b

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

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

Methods

pure :: a -> Day f g a

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

liftA2 :: (a -> b -> c) -> Day f g a -> Day f g b -> Day f g c

(*>) :: Day f g a -> Day f g b -> Day f g b

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

(Functor m, Monad m) => Applicative (ErrorT e m)

Methods

pure :: a -> ErrorT e m a

(<*>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

(*>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

Monoid m => Applicative (Holes t m)

Methods

pure :: a -> Holes t m a

(<*>) :: Holes t m (a -> b) -> Holes t m a -> Holes t m b

liftA2 :: (a -> b -> c) -> Holes t m a -> Holes t m b -> Holes t m c

(*>) :: Holes t m a -> Holes t m b -> Holes t m b

(<*) :: Holes t m a -> Holes t m b -> Holes t m a

Applicative f => Applicative (Backwards * f)

Apply f-actions in the reverse order.

Methods

pure :: a -> Backwards * f a

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

liftA2 :: (a -> b -> c) -> Backwards * f a -> Backwards * f b -> Backwards * f c

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

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

Applicative (Indexed i a)

Methods

pure :: a -> Indexed i a a

(<*>) :: Indexed i a (a -> b) -> Indexed i a a -> Indexed i a b

liftA2 :: (a -> b -> c) -> Indexed i a a -> Indexed i a b -> Indexed i a c

(*>) :: Indexed i a a -> Indexed i a b -> Indexed i a b

(<*) :: Indexed i a a -> Indexed i a b -> Indexed i a a

Dim k n => Applicative (V k n)

Methods

pure :: a -> V k n a

(<*>) :: V k n (a -> b) -> V k n a -> V k n b

liftA2 :: (a -> b -> c) -> V k n a -> V k n b -> V k n c

(*>) :: V k n a -> V k n b -> V k n b

(<*) :: V k n a -> V k n b -> V k n a

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

Methods

pure :: a -> StateT s m a

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

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

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

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

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

Methods

pure :: a -> StateT s m a

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

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

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

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

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

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

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

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

Applicative f => Applicative (Star f a)

Methods

pure :: a -> Star f a a

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

liftA2 :: (a -> b -> c) -> Star f a a -> Star f a b -> Star f a c

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

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

Applicative (Costar f a)

Methods

pure :: a -> Costar f a a

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

liftA2 :: (a -> b -> c) -> Costar f a a -> Costar f a b -> Costar f a c

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

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

Applicative f => Applicative (Static f a)

Methods

pure :: a -> Static f a a

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

liftA2 :: (a -> b -> c) -> Static f a a -> Static f a b -> Static f a c

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

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

Applicative (Tagged k s)

Methods

pure :: a -> Tagged k s a

(<*>) :: Tagged k s (a -> b) -> Tagged k s a -> Tagged k s b

liftA2 :: (a -> b -> c) -> Tagged k s a -> Tagged k s b -> Tagged k s c

(*>) :: Tagged k s a -> Tagged k s b -> Tagged k s b

(<*) :: Tagged k s a -> Tagged k s b -> Tagged k s a

Applicative f => Applicative (Reverse * f)

Derived instance.

Methods

pure :: a -> Reverse * f a

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

liftA2 :: (a -> b -> c) -> Reverse * f a -> Reverse * f b -> Reverse * f c

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

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

Monoid a => Applicative (Constant * a)

Methods

pure :: a -> Constant * a a

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

liftA2 :: (a -> b -> c) -> Constant * a a -> Constant * a b -> Constant * a c

(*>) :: Constant * a a -> Constant * a b -> Constant * a b

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

Applicative ((->) LiftedRep LiftedRep a)

Since: 2.1

Methods

pure :: a -> (LiftedRep -> LiftedRep) a a

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

liftA2 :: (a -> b -> c) -> (LiftedRep -> LiftedRep) a a -> (LiftedRep -> LiftedRep) a b -> (LiftedRep -> LiftedRep) a c

(*>) :: (LiftedRep -> LiftedRep) a a -> (LiftedRep -> LiftedRep) a b -> (LiftedRep -> LiftedRep) a b

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

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

Since: 4.9.0.0

Methods

pure :: a -> (* :*: f) g a

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

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

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

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

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

Since: 4.9.0.0

Methods

pure :: a -> Product * f g a

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

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

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

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

(Monad f, Applicative f) => Applicative (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Methods

pure :: a -> WhenMatched f x y a

(<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c

(*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b

(<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a

(Applicative f, Monad f) => Applicative (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Methods

pure :: a -> WhenMissing f k x a

(<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c

(*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b

(<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a

Applicative (ContT k r m)

Methods

pure :: a -> ContT k r m a

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

liftA2 :: (a -> b -> c) -> ContT k r m a -> ContT k r m b -> ContT k r m c

(*>) :: ContT k r m a -> ContT k r m b -> ContT k r m b

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

Applicative m => Applicative (ReaderT * r m)

Methods

pure :: a -> ReaderT * r m a

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

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

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

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

Applicative f => Applicative (M1 * i c f)

Since: 4.9.0.0

Methods

pure :: a -> M1 * i c f a

(<*>) :: M1 * i c f (a -> b) -> M1 * i c f a -> M1 * i c f b

liftA2 :: (a -> b -> c) -> M1 * i c f a -> M1 * i c f b -> M1 * i c f c

(*>) :: M1 * i c f a -> M1 * i c f b -> M1 * i c f b

(<*) :: M1 * i c f a -> M1 * i c f b -> M1 * i c f a

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

Since: 4.9.0.0

Methods

pure :: a -> (* :.: *) f g a

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

liftA2 :: (a -> b -> c) -> (* :.: *) f g a -> (* :.: *) f g b -> (* :.: *) f g c

(*>) :: (* :.: *) f g a -> (* :.: *) f g b -> (* :.: *) f g b

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

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

Since: 4.9.0.0

Methods

pure :: a -> Compose * * f g a

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

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

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

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

(Monad f, Applicative f) => Applicative (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Methods

pure :: a -> WhenMatched f k x y a

(<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c

(*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b

(<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a

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

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

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

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

Reifies k s (ReifiedApplicative f) => Applicative (ReflectedApplicative k * f s)

Methods

pure :: a -> ReflectedApplicative k * f s a

(<*>) :: ReflectedApplicative k * f s (a -> b) -> ReflectedApplicative k * f s a -> ReflectedApplicative k * f s b

liftA2 :: (a -> b -> c) -> ReflectedApplicative k * f s a -> ReflectedApplicative k * f s b -> ReflectedApplicative k * f s c

(*>) :: ReflectedApplicative k * f s a -> ReflectedApplicative k * f s b -> ReflectedApplicative k * f s b

(<*) :: ReflectedApplicative k * f s a -> ReflectedApplicative k * f s b -> ReflectedApplicative k * f s a

(*>) :: Applicative f => forall a b. f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

(<*) :: Applicative f => forall a b. f a -> f b -> f a infixl 4

Sequence actions, discarding the value of the second argument.

(<$>) :: 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.

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

Lift a function to actions. This function may be used as a value for fmap in a Functor instance.

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

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

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

Lift a ternary function to actions.