Safe Haskell	Safe
Language	Haskell98

Lens.Family2.Stock

Contents

Lens Combinators
Stock Lenses
Stock Traversals
Stock SECs
Types
Re-exports

Description

This module contains lenses and traversals for common structures in Haskell. It also contains the combinators for lenses and traversals.

Synopsis

Lens Combinators

choosing :: Functor f => LensLike f a a' c c' -> LensLike f b b' c c' -> LensLike f (Either a b) (Either a' b') c c' #

choosing :: Lens a a' c c' -> Lens b b' c c' -> Lens (Either a b) (Either a' b') c c'

choosing :: Traversal a a' c c' -> Traversal b b' c c' -> Traversal (Either a b) (Either a' b') c c'

choosing :: Getter a a' c c' -> Getter b b' c c' -> Getter (Either a b) (Either a' b') c c'

choosing :: Fold a a' c c' -> Fold b b' c c' -> Fold (Either a b) (Either a' b') c c'

choosing :: Setter a a' c c' -> Setter b b' c c' -> Setter (Either a b) (Either a' b') c c'

Given two lens/traversal/getter/fold/setter families with the same substructure, make a new lens/traversal/getter/fold/setter on Either.

alongside :: Functor f => LensLike (AlongsideLeft f b2') a1 a1' b1 b1' -> LensLike (AlongsideRight f a1') a2 a2' b2 b2' -> LensLike f (a1, a2) (a1', a2') (b1, b2) (b1', b2') #

alongside :: Lens a1 a1' b1 b1' -> Lens a2 a2' b2 b2' -> Lens (a1, a2) (a1', a2') (b1, b2) (b1', b2')

alongside :: Getter a1 a1' b1 b1' -> Getter a2 a2' b2 b2' -> Getter (a1, a2) (a1', a2') (b1, b2) (b1', b2')

Given two lens/getter families, make a new lens/getter on their product.

beside :: Applicative f => LensLike f a a' c c' -> LensLike f b b' c c' -> LensLike f (a, b) (a', b') c c' #

beside :: Traversal a a' c c' -> Traversal b' b' c c' -> Traversal (a,b) (a',b') c c'

beside :: Fold a a' c c' -> Fold b' b' c c' -> Fold (a,b) (a',b') c c'

beside :: Setter a a' c c' -> Setter b' b' c c' -> Setter (a,b) (a',b') c c'

Given two traversals/folds/setters referencing a type c, create a traversal/fold/setter on the pair referencing c.

Stock Lenses

_1 :: Lens (a, b) (a', b) a a' #

Lens on the first element of a pair.

_2 :: Lens (a, b) (a, b') b b' #

Lens on the second element of a pair.

chosen :: Lens (Either a a) (Either b b) a b #

Lens on the Left or Right element of an (Either a a).

ix :: Eq k => k -> Lens' (k -> v) v #

Lens on a given point of a function.

at :: Ord k => k -> Lens' (Map k v) (Maybe v) #

Lens on a given point of a Map.

intAt :: Int -> Lens' (IntMap v) (Maybe v) #

Lens on a given point of a IntMap.

at' :: Ord k => k -> Lens' (Map k v) (Maybe v) #

Lens providing strict access to a given point of a Map.

intAt' :: Int -> Lens' (IntMap v) (Maybe v) #

Lens providing strict access to a given point of a IntMap.

contains :: Ord k => k -> Lens' (Set k) Bool #

Lens on a given point of a Set.

intContains :: Int -> Lens' IntSet Bool #

Lens on a given point of a IntSet.

Stock Traversals

both :: Traversal (a, a) (b, b) a b #

Traversals on both elements of a pair (a,a).

_Left :: Traversal (Either a b) (Either a' b) a a' #

Traversal on the Left element of an Either.

_Right :: Traversal (Either a b) (Either a b') b b' #

Traversal on the Right element of an Either.

_Just :: Traversal (Maybe a) (Maybe a') a a' #

Traversal on the Just element of a Maybe.

_Nothing :: Traversal' (Maybe a) () #

Traversal on the Nothing element of a Maybe.

ignored :: Traversal a a b b' #

The empty traveral on any type.

Stock SECs

mapped :: Functor f => Setter (f a) (f a') a a' #

An SEC referencing the parameter of a functor.

Types

data AlongsideLeft (f :: * -> *) b a :: (* -> *) -> * -> * -> * #

Instances

Functor f => Functor (AlongsideLeft f a)
Methods fmap :: (a -> b) -> AlongsideLeft f a a -> AlongsideLeft f a b # (<$) :: a -> AlongsideLeft f a b -> AlongsideLeft f a a #
Phantom f => Phantom (AlongsideLeft f a)
Methods coerce :: AlongsideLeft f a a -> AlongsideLeft f a b

data AlongsideRight (f :: * -> *) a b :: (* -> *) -> * -> * -> * #

Instances

Functor f => Functor (AlongsideRight f a)
Methods fmap :: (a -> b) -> AlongsideRight f a a -> AlongsideRight f a b # (<$) :: a -> AlongsideRight f a b -> AlongsideRight f a a #
Phantom f => Phantom (AlongsideRight f a)
Methods coerce :: AlongsideRight f a a -> AlongsideRight f a b

Re-exports

type Lens a a' b b' = forall f. Functor f => LensLike f a a' b b' #

type Lens' a b = forall f. Functor f => LensLike' f a b #

type Traversal a a' b b' = forall f. Applicative f => LensLike f a a' b b' #

type Traversal' a b = forall f. Applicative f => LensLike' f a b #

type Setter a a' b b' = forall f. Identical f => LensLike f a a' b b' #

type LensLike (f :: * -> *) a a' b b' = (b -> f b') -> a -> f a' #

type LensLike' (f :: * -> *) a b = (b -> f b) -> a -> f a #

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

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)

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 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 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 (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, `String`s 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) #
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 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 #
(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 #
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 #
(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 #
(Monoid c, Monad m) => Applicative (Zooming m c)
Methods pure :: a -> Zooming m c a # (<>) :: Zooming m c (a -> b) -> Zooming m c a -> Zooming m c b # liftA2 :: (a -> b -> c) -> Zooming m c a -> Zooming m c b -> Zooming m c c # (>) :: Zooming m c a -> Zooming m c b -> Zooming m c b # (<*) :: Zooming m c a -> Zooming m c b -> Zooming m c 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 #
(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 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 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 #
(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 #
(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 #
(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 ((->) 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 #
(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 #

class Applicative f => Identical (f :: * -> *) #

Minimal complete definition

extract

Instances

Identical Identity
Methods extract :: Identity a -> a
Identical f => Identical (Backwards * f)
Methods extract :: Backwards * f a -> a
(Identical f, Identical g) => Identical (Compose * * f g)
Methods extract :: Compose * * f g a -> a

Lens Combinators

Stock Lenses

Stock Traversals

Stock SECs

Types

Re-exports

ZipList (zipWithN f xs1 ... xsN)

`ZipList` (zipWithN f xs1 ... xsN)