relude-1.2.2.0: Safe, performant, user-friendly and lightweight Haskell Standard Library

Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2023 Kowainik
License | MIT
Maintainer | Kowainik <xrom.xkov@gmail.com>
Stability | Stable
Portability | Portable
Safe Haskell | Safe
Language | Haskell2010

Relude.Applicative

Contents

- Reexports
- Combinators

Description

This module contains reexports of `Applicative` and related functional. Additionally, it provides convenient combinators to work with `Applicative`.

Synopsis

- class Applicative f => Alternative (f :: Type -> Type) where
  - empty :: f a
  - (<|>) :: f a -> f a -> f a
  - some :: f a -> f [a]
  - many :: f a -> f [a]
- class Functor f => Applicative (f :: Type -> Type) where
  - pure :: a -> f a
  - (<*>) :: f (a -> b) -> f a -> f b
  - liftA2 :: (a -> b -> c) -> f a -> f b -> f c
  - (*>) :: f a -> f b -> f b
  - (<*) :: f a -> f b -> f a
- newtype Const a (b :: k) = Const {
  - getConst :: a
  }
- newtype ZipList a = ZipList {
  - getZipList :: [a]
  }
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- optional :: Alternative f => f a -> f (Maybe a)
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- pass :: Applicative f => f ()
- appliedTo :: Applicative f => f a -> f (a -> b) -> f b

# Reexports

Main data types and functions reexported from Control.Applicative.

class Applicative f => Alternative (f :: Type -> Type) 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 []

#### Examples

Expand

    >>> Nothing <|> Just 42
    Just 42

    >>> [1, 2] <|> [3, 4]
    [1,2,3,4]

    >>> empty <|> print (2^15)
    32768

Minimal complete definition

empty, (<|>)

Methods

empty :: f a #

The identity of `<|>`

    empty <|> a     == a
    a     <|> empty == a

(<|>) :: f a -> f a -> f a infixl 3 #

An associative binary operation

some :: f a -> f [a] #

One or more.

#### Examples

Expand

    >>> some (putStr "la")
    lalalalalalalalala... * goes on forever *

    >>> some Nothing
    nothing

    >>> take 5 <$> some (Just 1)
    * hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case `some parser` will attempt to parse `parser` one or more times until it fails.

many :: f a -> f [a] #

Zero or more.

#### Examples

Expand

    >>> many (putStr "la")
    lalalalalalalalala... * goes on forever *

    >>> many Nothing
    Just []

    >>> take 5 <$> many (Just 1)
    * hangs forever *

Note that this function can be used with Parsers based on Applicatives. In that case `many parser` will attempt to parse `parser` zero or more times until it fails.

#### Instances

Instances details

Alternative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods empty :: Seq a # (<|>) :: Seq a -> Seq a -> Seq a # some :: Seq a -> Seq [a] # many :: Seq a -> Seq [a] #
Alternative STM | Takes the first non-`retry`ing `STM` action. @since base-4.8.0.0
Instance details Defined in GHC.Internal.Conc.Sync Methods empty :: STM a # (<|>) :: STM a -> STM a -> STM a # some :: STM a -> STM [a] # many :: STM a -> STM [a] #
Alternative ZipList | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods empty :: ZipList a # (<|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [a] #
Alternative P | @since base-4.5.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods empty :: P a # (<|>) :: P a -> P a -> P a # some :: P a -> P [a] # many :: P a -> P [a] #
Alternative ReadP | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP Methods empty :: ReadP a # (<|>) :: ReadP a -> ReadP a -> ReadP a # some :: ReadP a -> ReadP [a] # many :: ReadP a -> ReadP [a] #
Alternative ReadPrec | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec Methods empty :: ReadPrec a # (<|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a # some :: ReadPrec a -> ReadPrec [a] # many :: ReadPrec a -> ReadPrec [a] #
Alternative IO | Takes the first non-throwing `IO` action's result. `empty` throws an exception. @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base Methods empty :: IO a # (<|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Alternative Maybe | Picks the leftmost `Just` value, or, alternatively, `Nothing`. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods empty :: Maybe a # (<|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Alternative [] | Combines lists by concatenation, starting from the empty list. @since base-2.01
Instance details Defined in GHC.Internal.Base Methods empty :: [a] # (<|>) :: [a] -> [a] -> [a] # some :: [a] -> [[a]] # many :: [a] -> [[a]] #
MonadPlus m => Alternative (WrappedMonad m) | Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedMonad m a # (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: WrappedMonad m a -> WrappedMonad m [a] # many :: WrappedMonad m a -> WrappedMonad m [a] #
ArrowPlus a => Alternative (ArrowMonad a) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods empty :: ArrowMonad a a0 # (<|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 # some :: ArrowMonad a a0 -> ArrowMonad a [a0] # many :: ArrowMonad a a0 -> ArrowMonad a [a0] #
Alternative (Proxy :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Proxy Methods empty :: Proxy a # (<|>) :: Proxy a -> Proxy a -> Proxy a # some :: Proxy a -> Proxy [a] # many :: Proxy a -> Proxy [a] #
Alternative (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: U1 a # (<|>) :: U1 a -> U1 a -> U1 a # some :: U1 a -> U1 [a] # many :: U1 a -> U1 [a] #
Alternative f => Alternative (Lift f) | A combination is `Pure` only either part is.
Instance details Defined in Control.Applicative.Lift Methods empty :: Lift f a # (<|>) :: Lift f a -> Lift f a -> Lift f a # some :: Lift f a -> Lift f [a] # many :: Lift f a -> Lift f [a] #
(Functor m, Monad m) => Alternative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods empty :: MaybeT m a # (<|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a # some :: MaybeT m a -> MaybeT m [a] # many :: MaybeT m a -> MaybeT m [a] #
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: base-2.1
Instance details Defined in Control.Applicative Methods empty :: WrappedArrow a b a0 # (<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0 # some :: WrappedArrow a b a0 -> WrappedArrow a b [a0] # many :: WrappedArrow a b a0 -> WrappedArrow a b [a0] #
Alternative m => Alternative (Kleisli m a) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods empty :: Kleisli m a a0 # (<|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 # some :: Kleisli m a a0 -> Kleisli m a [a0] # many :: Kleisli m a a0 -> Kleisli m a [a0] #
Alternative f => Alternative (Ap f) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods empty :: Ap f a # (<|>) :: Ap f a -> Ap f a -> Ap f a # some :: Ap f a -> Ap f [a] # many :: Ap f a -> Ap f [a] #
Alternative f => Alternative (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods empty :: Alt f a # (<|>) :: Alt f a -> Alt f a -> Alt f a # some :: Alt f a -> Alt f [a] # many :: Alt f a -> Alt f [a] #
(Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: Generically1 f a # (<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a # some :: Generically1 f a -> Generically1 f [a] # many :: Generically1 f a -> Generically1 f [a] #
Alternative f => Alternative (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: Rec1 f a # (<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Rec1 f a -> Rec1 f [a] # many :: Rec1 f a -> Rec1 f [a] #
Alternative f => Alternative (Backwards f) | Try alternatives in the same order as `f`.
Instance details Defined in Control.Applicative.Backwards Methods empty :: Backwards f a # (<|>) :: Backwards f a -> Backwards f a -> Backwards f a # some :: Backwards f a -> Backwards f [a] # many :: Backwards f a -> Backwards f [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods empty :: AccumT w m a # (<|>) :: AccumT w m a -> AccumT w m a -> AccumT w m a # some :: AccumT w m a -> AccumT w m [a] # many :: AccumT w m a -> AccumT w m [a] #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods empty :: ExceptT e m a # (<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
Alternative m => Alternative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods empty :: IdentityT m a # (<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a # some :: IdentityT m a -> IdentityT m [a] # many :: IdentityT m a -> IdentityT m [a] #
Alternative m => Alternative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods empty :: ReaderT r m a # (<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a # some :: ReaderT r m a -> ReaderT r m [a] # many :: ReaderT r m a -> ReaderT r m [a] #
(Functor m, MonadPlus m) => Alternative (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods empty :: SelectT r m a # (<|>) :: SelectT r m a -> SelectT r m a -> SelectT r m a # some :: SelectT r m a -> SelectT r m [a] # many :: SelectT r m a -> SelectT r m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods empty :: StateT s m a # (<|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, MonadPlus m) => Alternative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods empty :: StateT s m a # (<|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
(Functor m, MonadPlus m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
(Monoid w, Alternative m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
(Monoid w, Alternative m) => Alternative (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods empty :: WriterT w m a # (<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a # some :: WriterT w m a -> WriterT w m [a] # many :: WriterT w m a -> WriterT w m [a] #
Alternative f => Alternative (Reverse f) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods empty :: Reverse f a # (<|>) :: Reverse f a -> Reverse f a -> Reverse f a # some :: Reverse f a -> Reverse f [a] # many :: Reverse f a -> Reverse f [a] #
(Alternative f, Alternative g) => Alternative (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods empty :: Product f g a # (<|>) :: Product f g a -> Product f g a -> Product f g a # some :: Product f g a -> Product f g [a] # many :: Product f g a -> Product f g [a] #
(Alternative f, Alternative g) => Alternative (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: (f :*: g) a # (<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a # some :: (f :*: g) a -> (f :*: g) [a] # many :: (f :*: g) a -> (f :*: g) [a] #
(Alternative f, Applicative g) => Alternative (Compose f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods empty :: Compose f g a # (<|>) :: Compose f g a -> Compose f g a -> Compose f g a # some :: Compose f g a -> Compose f g [a] # many :: Compose f g a -> Compose f g [a] #
(Alternative f, Applicative g) => Alternative (f :.: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: (f :.: g) a # (<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a # some :: (f :.: g) a -> (f :.: g) [a] # many :: (f :.: g) a -> (f :.: g) [a] #
Alternative f => Alternative (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics Methods empty :: M1 i c f a # (<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: M1 i c f a -> M1 i c f [a] # many :: M1 i c f a -> M1 i c f [a] #
(Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #
(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods empty :: RWST r w s m a # (<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a # some :: RWST r w s m a -> RWST r w s m [a] # many :: RWST r w s m a -> RWST r w s m [a] #

class Functor f => Applicative (f :: Type -> Type) 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

-     m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

-     (*>) = (>>)

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

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value into the Structure.

#### Examples

Expand

    >>> pure 1 :: Maybe Int
    Just 1

    >>> pure 'z' :: [Char]
    "z"

    >>> pure (pure ":D") :: Maybe [String]
    Just [":D"]

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

#### Example

Expand

Used in combination with ``(<$>)``, ``(<*>)`` can be used to build a record.

    >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

    >>> produceFoo :: Applicative f => f Foo
    >>> produceBar :: Applicative f => f Bar
    >>> produceBaz :: Applicative f => f Baz

    >>> mkState :: Applicative f => f MyState
    >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

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 `<*>`.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of `<*>` and `fmap`.

#### Example

Expand

    >>> liftA2 (,) (Just 3) (Just 5)
    Just (3,5)

    >>> liftA2 (+) [1, 2, 3] [4, 5, 6]
    [5,6,7,6,7,8,7,8,9]

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

Sequence actions, discarding the value of the first argument.

#### Examples

Expand

If used in conjunction with the Applicative instance for `Maybe`, you can chain Maybe computations, with a possible "early return" in case of `Nothing`.

    >>> Just 2 *> Just 3
    Just 3

    >>> Nothing *> Just 3
    Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

    >>> import Data.Char
    >>> import GHC.Internal.Text.ParserCombinators.ReadP
    >>> let p = string "my name is " *> munch1 isAlpha <* eof
    >>> readP_to_S p "my name is Simon"
    [("Simon","")]

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

Sequence actions, discarding the value of the second argument.

#### Instances

Instances details

Applicative Complex | Since: base-4.9.0.0
Instance details Defined in Data.Complex 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 First | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 Max | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 Min | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup 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 Put |
Instance details Defined in Data.ByteString.Builder.Internal Methods pure :: a -> Put a # (<*>) :: Put (a -> b) -> Put a -> Put b # liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c # (*>) :: Put a -> Put b -> Put b # (<*) :: Put a -> Put b -> Put a #
Applicative Seq | Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal 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 Tree |
Instance details Defined in Data.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 NonEmpty | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Base 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 STM | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Conc.Sync 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 Identity | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity 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 First | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid 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 base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Monoid 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 Down | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods pure :: a -> Down a # (<*>) :: Down (a -> b) -> Down a -> Down b # liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c # (*>) :: Down a -> Down b -> Down b # (<*) :: Down a -> Down b -> Down a #
Applicative Dual | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal 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 Product | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal 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 Sum | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal 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 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 base-2.01
Instance details Defined in GHC.Internal.Functor.ZipList 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 Par1 | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 P | @since base-4.5.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP 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 ReadP | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadP 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 ReadPrec | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Text.ParserCombinators.ReadPrec 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 IO | @since base-2.01
Instance details Defined in GHC.Internal.Base 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 Q |
Instance details Defined in Language.Haskell.TH.Syntax 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 Maybe | @since base-2.01
Instance details Defined in GHC.Internal.Base 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 Solo | @since base-4.15
Instance details Defined in GHC.Internal.Base Methods pure :: a -> Solo a # (<*>) :: Solo (a -> b) -> Solo a -> Solo b # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c # (*>) :: Solo a -> Solo b -> Solo b # (<*) :: Solo a -> Solo b -> Solo a #
Applicative [] | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> [a] # (<*>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (*>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Monad m => Applicative (WrappedMonad m) | Since: base-2.1
Instance details Defined in Control.Applicative 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 #
Applicative (SetM s) |
Instance details Defined in Data.Graph Methods pure :: a -> SetM s a # (<*>) :: SetM s (a -> b) -> SetM s a -> SetM s b # liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c # (*>) :: SetM s a -> SetM s b -> SetM s b # (<*) :: SetM s a -> SetM s b -> SetM s a #
Arrow a => Applicative (ArrowMonad a) | @since base-4.6.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Applicative (Either e) | @since base-3.0
Instance details Defined in GHC.Internal.Data.Either 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 (Proxy :: Type -> Type) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Proxy 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 (U1 :: Type -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 #
Applicative (IParser t) |
Instance details Defined in Data.Text.Internal.Read Methods pure :: a -> IParser t a # (<*>) :: IParser t (a -> b) -> IParser t a -> IParser t b # liftA2 :: (a -> b -> c) -> IParser t a -> IParser t b -> IParser t c # (*>) :: IParser t a -> IParser t b -> IParser t b # (<*) :: IParser t a -> IParser t b -> IParser t a #
Applicative f => Applicative (Lift f) | A combination is `Pure` only if both parts are.
Instance details Defined in Control.Applicative.Lift Methods pure :: a -> Lift f a # (<*>) :: Lift f (a -> b) -> Lift f a -> Lift f b # liftA2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c # (*>) :: Lift f a -> Lift f b -> Lift f b # (<*) :: Lift f a -> Lift f b -> Lift f a #
(Functor m, Monad m) => Applicative (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe 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 #
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 base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, a0) # (<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b) # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) # (*>) :: (a, a0) -> (a, b) -> (a, b) # (<*) :: (a, a0) -> (a, b) -> (a, a0) #
Arrow a => Applicative (WrappedArrow a b) | Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
(Applicative f, Monad f) => Applicative (WhenMissing f x) | Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal 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 m => Applicative (Kleisli m a) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Control.Arrow Methods pure :: a0 -> Kleisli m a a0 # (<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c # (*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # (<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0 #
Monoid m => Applicative (Const m :: Type -> Type) | @since base-2.0.1
Instance details Defined in GHC.Internal.Data.Functor.Const 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 (Ap f) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Data.Monoid Methods pure :: a -> Ap f a # (<*>) :: Ap f (a -> b) -> Ap f a -> Ap f b # liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c # (*>) :: Ap f a -> Ap f b -> Ap f b # (<*) :: Ap f a -> Ap f b -> Ap f a #
Applicative f => Applicative (Alt f) | @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Semigroup.Internal 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 #
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | @since base-4.17.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a #
Applicative f => Applicative (Rec1 f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 #
Applicative (t m) => Applicative (LiftingAccum t m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Accum Methods pure :: a -> LiftingAccum t m a # (<*>) :: LiftingAccum t m (a -> b) -> LiftingAccum t m a -> LiftingAccum t m b # liftA2 :: (a -> b -> c) -> LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m c # (*>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # (<*) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m a #
Applicative (t m) => Applicative (LiftingSelect t m) | Since: mtl-2.3
Instance details Defined in Control.Monad.Select Methods pure :: a -> LiftingSelect t m a # (<*>) :: LiftingSelect t m (a -> b) -> LiftingSelect t m a -> LiftingSelect t m b # liftA2 :: (a -> b -> c) -> LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m c # (*>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # (<*) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m a #
Applicative f => Applicative (Backwards f) | Apply `f`-actions in the reverse order.
Instance details Defined in Control.Applicative.Backwards 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 #
(Monoid w, Functor m, Monad m) => Applicative (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods pure :: a -> AccumT w m a # (<*>) :: AccumT w m (a -> b) -> AccumT w m a -> AccumT w m b # liftA2 :: (a -> b -> c) -> AccumT w m a -> AccumT w m b -> AccumT w m c # (*>) :: AccumT w m a -> AccumT w m b -> AccumT w m b # (<*) :: AccumT w m a -> AccumT w m b -> AccumT w m a #
(Functor m, Monad m) => Applicative (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except 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 #
Applicative m => Applicative (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity 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 m => Applicative (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader 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 #
(Functor m, Monad m) => Applicative (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods pure :: a -> SelectT r m a # (<*>) :: SelectT r m (a -> b) -> SelectT r m a -> SelectT r m b # liftA2 :: (a -> b -> c) -> SelectT r m a -> SelectT r m b -> SelectT r m c # (*>) :: SelectT r m a -> SelectT r m b -> SelectT r m b # (<*) :: SelectT r m a -> SelectT r m b -> SelectT r m a #
(Functor m, Monad m) => Applicative (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy 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) |
Instance details Defined in Control.Monad.Trans.State.Strict 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 (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS 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) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy 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) |
Instance details Defined in Control.Monad.Trans.Writer.Strict 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 a => Applicative (Constant a :: Type -> Type) |
Instance details Defined in Data.Functor.Constant Methods pure :: a0 -> Constant a a0 # (<*>) :: Constant a (a0 -> b) -> Constant a a0 -> Constant a b # liftA2 :: (a0 -> b -> c) -> Constant a a0 -> Constant a b -> Constant a c # (*>) :: Constant a a0 -> Constant a b -> Constant a b # (<*) :: Constant a a0 -> Constant a b -> Constant a a0 #
Applicative f => Applicative (Reverse f) | Derived instance.
Instance details Defined in Data.Functor.Reverse 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, Monoid b) => Applicative ((,,) a b) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, a0) # (<*>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) # (*>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) #
(Applicative f, Applicative g) => Applicative (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product 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)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal 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))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal 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 f, Applicative g) => Applicative (f :*: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 #
Monoid c => Applicative (K1 i c :: Type -> Type) | @since base-4.12.0.0
Instance details Defined in GHC.Internal.Generics Methods pure :: a -> K1 i c a # (<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 # (*>) :: K1 i c a -> K1 i c b -> K1 i c b # (<*) :: K1 i c a -> K1 i c b -> K1 i c a #
Applicative (ContT r m) |
Instance details Defined in Control.Monad.Trans.Cont Methods pure :: a -> ContT r m a # (<*>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b # liftA2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c # (*>) :: ContT r m a -> ContT r m b -> ContT r m b # (<*) :: ContT r m a -> ContT r m b -> ContT r m a #
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Base Methods pure :: a0 -> (a, b, c, a0) # (<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) # (*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) #
Applicative ((->) r) | @since base-2.01
Instance details Defined in GHC.Internal.Base Methods pure :: a -> r -> a # (<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (*>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
(Applicative f, Applicative g) => Applicative (Compose f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose 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)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal 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 #
(Applicative f, Applicative g) => Applicative (f :.: g) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 (M1 i c f) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Generics 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 -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 # (*>) :: 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 #
(Functor m, Monad m) => Applicative (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS 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) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy 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) |
Instance details Defined in Control.Monad.Trans.RWS.Strict 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 #

newtype Const a (b :: k) #

The `Const` functor.

#### Examples

Expand

    >>> fmap (++ "World") (Const "Hello")
    Const "Hello"

Because we ignore the second type parameter to `Const`, the Applicative instance, which has ``(<*>)` :: Monoid m => Const m (a -> b) -> Const m a -> Const m b` essentially turns into `Monoid m => m -> m -> m`, which is `(<>)`

    >>> Const [1, 2, 3] <*> Const [4, 5, 6]
    Const [1,2,3,4,5,6]

Constructors

Const |
Fields getConst :: a

#### Instances

Instances details

Generic1 (Const a :: k -> Type) |
Instance details Defined in GHC.Internal.Data.Functor.Const Associated Types
type Rep1 (Const a :: k -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "GHC.Internal.Data.Functor.Const" "ghc-internal" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
Methods from1 :: forall (a0 :: k). Const a a0 -> Rep1 (Const a :: k -> Type) a0 # to1 :: forall (a0 :: k). Rep1 (Const a :: k -> Type) a0 -> Const a a0 #
Bifoldable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => Const m m -> m # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c #
Bifoldable1 (Const :: Type -> Type -> Type) |
Instance details Defined in Data.Bifoldable1 Methods bifold1 :: Semigroup m => Const m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const a b -> m #
Bifunctor (Const :: Type -> Type -> Type) | Since: base-4.8.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d # first :: (a -> b) -> Const a c -> Const b c # second :: (b -> c) -> Const a b -> Const a c #
Bitraversable (Const :: Type -> Type -> Type) | Since: base-4.10.0.0
Instance details Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const a b -> f (Const c d) #
Eq2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const a c -> Const b d -> Bool #
Ord2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering #
Read2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b] #
Show2 (Const :: Type -> Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS #
NFData2 (Const :: Type -> Type -> Type) | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> Const a b -> () #
Hashable2 (Const :: Type -> Type -> Type) |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int #
Eq a => Eq1 (Const a :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftEq :: (a0 -> b -> Bool) -> Const a a0 -> Const a b -> Bool #
Ord a => Ord1 (Const a :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering #
Read a => Read1 (Const a :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0] #
Show a => Show1 (Const a :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Classes Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS #
Contravariant (Const a :: Type -> Type) |
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a0) -> Const a a0 -> Const a a' # (>$) :: b -> Const a b -> Const a a0 #
NFData a => NFData1 (Const a :: Type -> Type) | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a0 -> ()) -> Const a a0 -> () #
Monoid m => Applicative (Const m :: Type -> Type) | @since base-2.0.1
Instance details Defined in GHC.Internal.Data.Functor.Const 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 #
Functor (Const m :: Type -> Type) | @since base-2.01
Instance details Defined in GHC.Internal.Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Foldable (Const m :: Type -> Type) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 # foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b # foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b # foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] # null :: Const m a -> Bool # length :: Const m a -> Int # elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # sum :: Num a => Const m a -> a # product :: Num a => Const m a -> a #
Traversable (Const m :: Type -> Type) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b) # sequenceA :: Applicative f => Const m (f a) -> f (Const m a) # mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b) # sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a) #
Hashable a => Hashable1 (Const a :: Type -> Type) |
Instance details Defined in Data.Hashable.Class Methods liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int #
NFData a => NFData (Const a b) | Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: Const a b -> () #
Monoid a => Monoid (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Semigroup a => Semigroup (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
Bits a => Bits (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods (.&.) :: Const a b -> Const a b -> Const a b # (.|.) :: Const a b -> Const a b -> Const a b # xor :: Const a b -> Const a b -> Const a b # complement :: Const a b -> Const a b # shift :: Const a b -> Int -> Const a b # rotate :: Const a b -> Int -> Const a b # zeroBits :: Const a b # bit :: Int -> Const a b # setBit :: Const a b -> Int -> Const a b # clearBit :: Const a b -> Int -> Const a b # complementBit :: Const a b -> Int -> Const a b # testBit :: Const a b -> Int -> Bool # bitSizeMaybe :: Const a b -> Maybe Int # bitSize :: Const a b -> Int # isSigned :: Const a b -> Bool # shiftL :: Const a b -> Int -> Const a b # unsafeShiftL :: Const a b -> Int -> Const a b # shiftR :: Const a b -> Int -> Const a b # unsafeShiftR :: Const a b -> Int -> Const a b # rotateL :: Const a b -> Int -> Const a b # rotateR :: Const a b -> Int -> Const a b # popCount :: Const a b -> Int #
FiniteBits a => FiniteBits (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods finiteBitSize :: Const a b -> Int # countLeadingZeros :: Const a b -> Int # countTrailingZeros :: Const a b -> Int #
(Typeable k, Data a, Typeable b) => Data (Const a b) | @since base-4.10.0.0
Instance details Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) # gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) # toConstr :: Const a b -> Constr # dataTypeOf :: Const a b -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) # gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) #
IsString a => IsString (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.String Methods fromString :: String -> Const a b #
Bounded a => Bounded (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
Enum a => Enum (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Floating a => Floating (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods pi :: Const a b # exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # log1pexp :: Const a b -> Const a b # log1mexp :: Const a b -> Const a b #
RealFloat a => RealFloat (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isNaN :: Const a b -> Bool # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # isIEEE :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b #
Storable a => Storable (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods sizeOf :: Const a b -> Int # alignment :: Const a b -> Int # peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b) # pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO () # peekByteOff :: Ptr b0 -> Int -> IO (Const a b) # pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO () # peek :: Ptr (Const a b) -> IO (Const a b) # poke :: Ptr (Const a b) -> Const a b -> IO () #
Generic (Const a b) |
Instance details Defined in GHC.Internal.Data.Functor.Const Associated Types
type Rep (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "GHC.Internal.Data.Functor.Const" "ghc-internal" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
Methods from :: Const a b -> Rep (Const a b) x # to :: Rep (Const a b) x -> Const a b #
Ix a => Ix (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods range :: (Const a b, Const a b) -> [Const a b] # index :: (Const a b, Const a b) -> Const a b -> Int # unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int # inRange :: (Const a b, Const a b) -> Const a b -> Bool # rangeSize :: (Const a b, Const a b) -> Int # unsafeRangeSize :: (Const a b, Const a b) -> Int #
Num a => Num (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods (+) :: Const a b -> Const a b -> Const a b # (-) :: Const a b -> Const a b -> Const a b # (*) :: Const a b -> Const a b -> Const a b # negate :: Const a b -> Const a b # abs :: Const a b -> Const a b # signum :: Const a b -> Const a b # fromInteger :: Integer -> Const a b #
Read a => Read (Const a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods readsPrec :: Int -> ReadS (Const a b) # readList :: ReadS [Const a b] # readPrec :: ReadPrec (Const a b) # readListPrec :: ReadPrec [Const a b] #
Fractional a => Fractional (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods (/) :: Const a b -> Const a b -> Const a b # recip :: Const a b -> Const a b # fromRational :: Rational -> Const a b #
Integral a => Integral (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b # mod :: Const a b -> Const a b -> Const a b # quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # toInteger :: Const a b -> Integer #
Real a => Real (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods toRational :: Const a b -> Rational #
RealFrac a => RealFrac (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #
Show a => Show (Const a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed @since base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Eq a => Eq (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods (==) :: Const a b -> Const a b -> Bool # (/=) :: Const a b -> Const a b -> Bool #
Ord a => Ord (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods compare :: Const a b -> Const a b -> Ordering # (<) :: Const a b -> Const a b -> Bool # (<=) :: Const a b -> Const a b -> Bool # (>) :: Const a b -> Const a b -> Bool # (>=) :: Const a b -> Const a b -> Bool # max :: Const a b -> Const a b -> Const a b # min :: Const a b -> Const a b -> Const a b #
Hashable a => Hashable (Const a b) |
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Const a b -> Int # hash :: Const a b -> Int #
type Rep1 (Const a :: k -> Type) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "GHC.Internal.Data.Functor.Const" "ghc-internal" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Rep (Const a b) | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const type Rep (Const a b) = D1 ('MetaData "Const" "GHC.Internal.Data.Functor.Const" "ghc-internal" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype ZipList a #

Lists, but with an `Applicative` functor based on zipping.

#### Examples

Expand

In contrast to the `Applicative` for `List`:

    >>> (+) <$> [1, 2, 3] <*> [4, 5, 6]
    [5,6,7,6,7,8,7,8,9]

The Applicative instance of ZipList applies the operation by pairing up the elements, analogous to `zipWith`N

    >>> (+) <$> ZipList [1, 2, 3] <*> ZipList [4, 5, 6]
    ZipList {getZipList = [5,7,9]}

    >>> (,,,) <$> ZipList [1, 2] <*> ZipList [3, 4] <*> ZipList [5, 6] <*> ZipList [7, 8]
    ZipList {getZipList = [(1,3,5,7),(2,4,6,8)]}

    >>> ZipList [(+1), (^2), (/ 2)] <*> ZipList [5, 5, 5]
    ZipList {getZipList = [6.0,25.0,2.5]}

Constructors

ZipList |
Fields getZipList :: [a]

#### Instances

Instances details

NFData1 ZipList | Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> ZipList a -> () #
Alternative ZipList | @since base-4.11.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods empty :: ZipList a # (<|>) :: ZipList a -> ZipList a -> ZipList a # some :: ZipList a -> ZipList [a] # many :: ZipList a -> ZipList [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 base-2.01
Instance details Defined in GHC.Internal.Functor.ZipList 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 #
Functor ZipList | @since base-2.01
Instance details Defined in GHC.Internal.Functor.ZipList Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Foldable ZipList | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods fold :: Monoid m => ZipList m -> m # foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m # foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b # foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b # foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] # null :: ZipList a -> Bool # length :: ZipList a -> Int # elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # sum :: Num a => ZipList a -> a # product :: Num a => ZipList a -> a #
Traversable ZipList | @since base-4.9.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Generic1 ZipList |
Instance details Defined in GHC.Internal.Functor.ZipList Associated Types
type Rep1 ZipList | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList type Rep1 ZipList = D1 ('MetaData "ZipList" "GHC.Internal.Functor.ZipList" "ghc-internal" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))
Methods from1 :: ZipList a -> Rep1 ZipList a # to1 :: Rep1 ZipList a -> ZipList a #
NFData a => NFData (ZipList a) | Since: deepseq-1.4.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: ZipList a -> () #
Data a => Data (ZipList a) | @since base-4.14.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) # toConstr :: ZipList a -> Constr # dataTypeOf :: ZipList a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) # gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r # gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) #
Generic (ZipList a) |
Instance details Defined in GHC.Internal.Functor.ZipList Associated Types
type Rep (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList type Rep (ZipList a) = D1 ('MetaData "ZipList" "GHC.Internal.Functor.ZipList" "ghc-internal" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
Methods from :: ZipList a -> Rep (ZipList a) x # to :: Rep (ZipList a) x -> ZipList a #
IsList (ZipList a) | @since base-4.15.0.0
Instance details Defined in GHC.Internal.IsList Associated Types
type Item (ZipList a) |
Instance details Defined in GHC.Internal.IsList type Item (ZipList a) = a
Methods fromList :: [Item (ZipList a)] -> ZipList a # fromListN :: Int -> [Item (ZipList a)] -> ZipList a # toList :: ZipList a -> [Item (ZipList a)] #
Read a => Read (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods readsPrec :: Int -> ReadS (ZipList a) # readList :: ReadS [ZipList a] # readPrec :: ReadPrec (ZipList a) # readListPrec :: ReadPrec [ZipList a] #
Show a => Show (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Eq a => Eq (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Ord a => Ord (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList Methods compare :: ZipList a -> ZipList a -> Ordering # (<) :: ZipList a -> ZipList a -> Bool # (<=) :: ZipList a -> ZipList a -> Bool # (>) :: ZipList a -> ZipList a -> Bool # (>=) :: ZipList a -> ZipList a -> Bool # max :: ZipList a -> ZipList a -> ZipList a # min :: ZipList a -> ZipList a -> ZipList a #
type Rep1 ZipList | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList type Rep1 ZipList = D1 ('MetaData "ZipList" "GHC.Internal.Functor.ZipList" "ghc-internal" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))
type Rep (ZipList a) | @since base-4.7.0.0
Instance details Defined in GHC.Internal.Functor.ZipList type Rep (ZipList a) = D1 ('MetaData "ZipList" "GHC.Internal.Functor.ZipList" "ghc-internal" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))
type Item (ZipList a) |
Instance details Defined in GHC.Internal.IsList type Item (ZipList a) = a

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

Lift a ternary function to actions.

optional :: Alternative f => f a -> f (Maybe a) #

One or none.

It is useful for modelling any computation that is allowed to fail.

#### Examples

Expand

Using the `Alternative` instance of Control.Monad.Except, the following functions:

    >>> import Control.Monad.Except

    >>> canFail = throwError "it failed" :: Except String Int
    >>> final = return 42                :: Except String Int

Can be combined by allowing the first function to fail:

    >>> runExcept $ canFail *> final
    Left "it failed"

    >>> runExcept $ optional canFail *> final
    Right 42

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

A variant of `<*>` with the types of the arguments reversed. It differs from ``flip` `(<*>)`` in that the effects are resolved in the order the arguments are presented.

#### Examples

Expand

    >>> (<**>) (print 1) (id <$ print 2)
    1
    2

    >>> flip (<*>) (print 1) (id <$ print 2)
    2
    1

    >>> ZipList [4, 5, 6] <**> ZipList [(+1), (*2), (/3)]
    ZipList {getZipList = [5.0,10.0,2.0]}

# Combinators

pass :: Applicative f => f () #

Shorter alias for `pure ()`.

    >>> pass :: Maybe ()
    Just ()

Useful shortcut when need an empty action:

    printJust :: Maybe Int -> IO ()
    printJust mInt = case mInt of
        Just i -> putStrLn $ "Number: " ++ show i
        Nothing -> pass

appliedTo :: Applicative f => f a -> f (a -> b) -> f b #

Named version of the `<**>` operator, which is `<*>` but flipped. It is helpful for chaining applicative operations in forward applications using `&`.

    >>> Just (+ 1) & appliedTo (Just 2)
    Just 3
    >>> Just (+) & appliedTo (Just 1) & appliedTo (Just 2)
    Just 3
    >>> Nothing & appliedTo (Just 2)
    Nothing

Since: 0.5.0