semigroupoids-6.0.0.1: Semigroupoids: Category sans id

Copyright | (C) 2011-2015 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Functor.Apply

Contents

- Functors
- Apply - a strong lax semimonoidal endofunctor
- Wrappers

Description

Synopsis

- class Functor (f :: Type -> Type) where
  - fmap :: (a -> b) -> f a -> f b
  - (<$) :: a -> f b -> f a
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- ($>) :: Functor f => f a -> b -> f b
- class Functor f => Apply (f :: Type -> Type) where
  - (<.>) :: f (a -> b) -> f a -> f b
  - (.>) :: f a -> f b -> f b
  - (<.) :: f a -> f b -> f a
  - liftF2 :: (a -> b -> c) -> f a -> f b -> f c
- (<..>) :: Apply w => w a -> w (a -> b) -> w b
- liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- gliftF2 :: (Generic1 w, Apply (Rep1 w)) => (a -> b -> c) -> w a -> w b -> w c
- gliftF3 :: (Generic1 w, Apply (Rep1 w)) => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- newtype WrappedApplicative (f :: Type -> Type) a = WrapApplicative {
  - unwrapApplicative :: f a
  }
- newtype MaybeApply (f :: Type -> Type) a = MaybeApply {
  - runMaybeApply :: Either (f a) a
  }
- (<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b
- (<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b

# Functors

class Functor (f :: Type -> Type) where #

A type `f` is a Functor if it provides a function `fmap` which, given any types `a` and `b` lets you apply any function from `(a -> b)` to turn an `f a` into an `f b`, preserving the structure of `f`. Furthermore `f` needs to adhere to the following:

Identity
  ``fmap` `id` == `id``
Composition
  ``fmap` (f . g) == `fmap` f . `fmap` g`

Note, that the second law follows from the free theorem of the type `fmap` and the first law, so you need only check that the former condition holds. See https://www.schoolofhaskell.com/user/edwardk/snippets/fmap or https://github.com/quchen/articles/blob/master/second_functor_law.md for an explanation.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b #

`fmap` is used to apply a function of type `(a -> b)` to a value of type `f a`, where f is a functor, to produce a value of type `f b`. Note that for any type constructor with more than one parameter (e.g., `Either`), only the last type parameter can be modified with `fmap` (e.g., `b` in `Either a b`).

Some type constructors with two parameters or more have a ``Bifunctor`` instance that allows both the last and the penultimate parameters to be mapped over.

#### Examples

Expand

Convert from a ``Maybe` Int` to a `Maybe String` using `show`:

    >>> fmap show Nothing
    Nothing
    >>> fmap show (Just 3)
    Just "3"

Convert from an ``Either` Int Int` to an `Either Int String` using `show`:

    >>> fmap show (Left 17)
    Left 17
    >>> fmap show (Right 17)
    Right "17"

Double each element of a list:

    >>> fmap (*2) [1,2,3]
    [2,4,6]

Apply `even` to the second element of a pair:

    >>> fmap even (2,2)
    (2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements `(a,b,c)` can also be written `(,,) a b c` and its `Functor` instance is defined for `Functor ((,,) a b)` (i.e., only the third parameter is free to be mapped over with `fmap`).

It explains why `fmap` can be used with tuples containing values of different types as in the following example:

    >>> fmap even ("hello", 1.0, 4)
    ("hello",1.0,True)

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

Replace all locations in the input with the same value. The default definition is ``fmap` . `const``, but this may be overridden with a more efficient version.

#### Examples

Expand

Perform a computation with `Maybe` and replace the result with a constant value if it is `Just`:

    >>> 'a' <$ Just 2
    Just 'a'
    >>> 'a' <$ Nothing
    Nothing

#### Instances

Instances details

Functor ZipList | Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Handler | Since: base-4.6.0.0
Instance details Defined in Control.Exception Methods fmap :: (a -> b) -> Handler a -> Handler b # (<$) :: a -> Handler b -> Handler a #
Functor Complex | Since: base-4.9.0.0
Instance details Defined in Data.Complex Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Functor Identity | Since: base-4.8.0.0
Instance details Defined in Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor First | Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last | Since: base-4.8.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Down | Since: base-4.11.0.0
Instance details Defined in Data.Ord Methods fmap :: (a -> b) -> Down a -> Down b # (<$) :: a -> Down b -> Down a #
Functor First | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Max | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor Min | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor Dual | Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Product | Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor Sum | Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor NonEmpty | Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor STM | Since: base-4.3.0.0
Instance details Defined in GHC.Conc.Sync Methods fmap :: (a -> b) -> STM a -> STM b # (<$) :: a -> STM b -> STM a #
Functor NoIO | Since: base-4.8.0.0
Instance details Defined in GHC.GHCi Methods fmap :: (a -> b) -> NoIO a -> NoIO b # (<$) :: a -> NoIO b -> NoIO a #
Functor Par1 | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor ArgDescr | Since: base-4.7.0.0
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> ArgDescr a -> ArgDescr b # (<$) :: a -> ArgDescr b -> ArgDescr a #
Functor ArgOrder | Since: base-4.7.0.0
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> ArgOrder a -> ArgOrder b # (<$) :: a -> ArgOrder b -> ArgOrder a #
Functor OptDescr | Since: base-4.7.0.0
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> OptDescr a -> OptDescr b # (<$) :: a -> OptDescr b -> OptDescr a #
Functor P | Since: base-4.8.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor ReadP | Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor ReadPrec | Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadPrec Methods fmap :: (a -> b) -> ReadPrec a -> ReadPrec b # (<$) :: a -> ReadPrec b -> ReadPrec a #
Functor SCC | Since: containers-0.5.4
Instance details Defined in Data.Graph Methods fmap :: (a -> b) -> SCC a -> SCC b # (<$) :: a -> SCC b -> SCC a #
Functor IntMap |
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Digit |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Elem |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor FingerTree |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor Node |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Seq |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor ViewL |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR |
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor Tree |
Instance details Defined in Data.Tree Methods fmap :: (a -> b) -> Tree a -> Tree b # (<$) :: a -> Tree b -> Tree a #
Functor IO | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor AnnotDetails |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b # (<$) :: a -> AnnotDetails b -> AnnotDetails a #
Functor Doc |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Doc a -> Doc b # (<$) :: a -> Doc b -> Doc a #
Functor Span |
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Span a -> Span b # (<$) :: a -> Span b -> Span a #
Functor PprM |
Instance details Defined in Language.Haskell.TH.PprLib Methods fmap :: (a -> b) -> PprM a -> PprM b # (<$) :: a -> PprM b -> PprM a #
Functor Q |
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor TyVarBndr |
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b # (<$) :: a -> TyVarBndr b -> TyVarBndr a #
Functor Maybe | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor Solo | Since: base-4.15
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Solo a -> Solo b # (<$) :: a -> Solo b -> Solo a #
Functor [] | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Monad m => Functor (WrappedMonad m) | Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Arrow a => Functor (ArrowMonad a) | Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Functor (Either a) | Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (Proxy :: Type -> Type) | Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Functor (Arg a) | Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b # (<$) :: a0 -> Arg a b -> Arg a a0 #
Functor (Array i) | Since: base-2.1
Instance details Defined in GHC.Arr Methods fmap :: (a -> b) -> Array i a -> Array i b # (<$) :: a -> Array i b -> Array i a #
Functor (U1 :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor (V1 :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor (ST s) | Since: base-2.1
Instance details Defined in GHC.ST Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (SetM s) |
Instance details Defined in Data.Graph Methods fmap :: (a -> b) -> SetM s a -> SetM s b # (<$) :: a -> SetM s b -> SetM s a #
Functor (Map k) |
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Functor f => Functor (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b # (<$) :: a -> MaybeApply f b -> MaybeApply f a #
Functor f => Functor (WrappedApplicative f) # |
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a #
Functor f => Functor (Lift f) |
Instance details Defined in Control.Applicative.Lift Methods fmap :: (a -> b) -> Lift f a -> Lift f b # (<$) :: a -> Lift f b -> Lift f a #
Functor m => Functor (MaybeT m) |
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Functor (HashMap k) |
Instance details Defined in Data.HashMap.Internal Methods fmap :: (a -> b) -> HashMap k a -> HashMap k b # (<$) :: a -> HashMap k b -> HashMap k a #
Functor ((,) a) | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
Arrow a => Functor (WrappedArrow a b) | Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Functor m => Functor (Kleisli m a) | Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 #
Functor (Const m :: Type -> Type) | Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Functor f => Functor (Ap f) | Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b # (<$) :: a -> Ap f b -> Ap f a #
Functor f => Functor (Alt f) | Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b # (<$) :: a -> Alt f b -> Alt f a #
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | Since: base-4.17.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Generically1 f a -> Generically1 f b # (<$) :: a -> Generically1 f b -> Generically1 f a #
Functor f => Functor (Rec1 f) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec (Ptr ()) :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor (URec Char :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Functor (Mag a b) |
Instance details Defined in Data.Biapplicative Methods fmap :: (a0 -> b0) -> Mag a b a0 -> Mag a b b0 # (<$) :: a0 -> Mag a b b0 -> Mag a b a0 #
Functor (bi a) => Functor (Biap bi a) |
Instance details Defined in Data.Bifunctor.Biap Methods fmap :: (a0 -> b) -> Biap bi a a0 -> Biap bi a b # (<$) :: a0 -> Biap bi a b -> Biap bi a a0 #
Bifunctor p => Functor (Fix p) |
Instance details Defined in Data.Bifunctor.Fix Methods fmap :: (a -> b) -> Fix p a -> Fix p b # (<$) :: a -> Fix p b -> Fix p a #
Bifunctor p => Functor (Join p) |
Instance details Defined in Data.Bifunctor.Join Methods fmap :: (a -> b) -> Join p a -> Join p b # (<$) :: a -> Join p b -> Join p a #
Functor w => Functor (EnvT e w) |
Instance details Defined in Control.Comonad.Trans.Env Methods fmap :: (a -> b) -> EnvT e w a -> EnvT e w b # (<$) :: a -> EnvT e w b -> EnvT e w a #
Functor w => Functor (StoreT s w) |
Instance details Defined in Control.Comonad.Trans.Store Methods fmap :: (a -> b) -> StoreT s w a -> StoreT s w b # (<$) :: a -> StoreT s w b -> StoreT s w a #
Functor w => Functor (TracedT m w) |
Instance details Defined in Control.Comonad.Trans.Traced Methods fmap :: (a -> b) -> TracedT m w a -> TracedT m w b # (<$) :: a -> TracedT m w b -> TracedT m w a #
(Applicative f, Monad f) => Functor (WhenMissing f x) | Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b # (<$) :: a -> WhenMissing f x b -> WhenMissing f x a #
(Contravariant f, Contravariant g) => Functor (Compose f g) |
Instance details Defined in Data.Functor.Contravariant.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (ComposeCF f g) |
Instance details Defined in Data.Functor.Contravariant.Compose Methods fmap :: (a -> b) -> ComposeCF f g a -> ComposeCF f g b # (<$) :: a -> ComposeCF f g b -> ComposeCF f g a #
(Functor f, Functor g) => Functor (ComposeFC f g) |
Instance details Defined in Data.Functor.Contravariant.Compose Methods fmap :: (a -> b) -> ComposeFC f g a -> ComposeFC f g b # (<$) :: a -> ComposeFC f g b -> ComposeFC f g a #
Functor f => Functor (Static f a) # |
Instance details Defined in Data.Semigroupoid.Static Methods fmap :: (a0 -> b) -> Static f a a0 -> Static f a b # (<$) :: a0 -> Static f a b -> Static f a a0 #
Functor (Tagged s) |
Instance details Defined in Data.Tagged Methods fmap :: (a -> b) -> Tagged s a -> Tagged s b # (<$) :: a -> Tagged s b -> Tagged s a #
Functor f => Functor (Backwards f) | Derived instance.
Instance details Defined in Control.Applicative.Backwards Methods fmap :: (a -> b) -> Backwards f a -> Backwards f b # (<$) :: a -> Backwards f b -> Backwards f a #
Functor m => Functor (AccumT w m) |
Instance details Defined in Control.Monad.Trans.Accum Methods fmap :: (a -> b) -> AccumT w m a -> AccumT w m b # (<$) :: a -> AccumT w m b -> AccumT w m a #
Functor m => Functor (ExceptT e m) |
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (IdentityT m) |
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b # (<$) :: a -> IdentityT m b -> IdentityT m a #
Functor m => Functor (ReaderT r m) |
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (SelectT r m) |
Instance details Defined in Control.Monad.Trans.Select Methods fmap :: (a -> b) -> SelectT r m a -> SelectT r m b # (<$) :: a -> SelectT r m b -> SelectT r m a #
Functor m => Functor (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m) |
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor m => Functor (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor m => Functor (WriterT w m) |
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor (Constant a :: Type -> Type) |
Instance details Defined in Data.Functor.Constant Methods fmap :: (a0 -> b) -> Constant a a0 -> Constant a b # (<$) :: a0 -> Constant a b -> Constant a a0 #
Functor f => Functor (Reverse f) | Derived instance.
Instance details Defined in Data.Functor.Reverse Methods fmap :: (a -> b) -> Reverse f a -> Reverse f b # (<$) :: a -> Reverse f b -> Reverse f a #
Functor ((,,) a b) | Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) #
(Functor f, Functor g) => Functor (Product f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Product Methods fmap :: (a -> b) -> Product f g a -> Product f g b # (<$) :: a -> Product f g b -> Product f g a #
(Functor f, Functor g) => Functor (Sum f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b # (<$) :: a -> Sum f g b -> Sum f g a #
(Functor f, Functor g) => Functor (f :*: g) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :*: g) a -> (f :*: g) b # (<$) :: a -> (f :*: g) b -> (f :*: g) a #
(Functor f, Functor g) => Functor (f :+: g) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
Functor (K1 i c :: Type -> Type) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
Functor (Cokleisli w a) |
Instance details Defined in Control.Comonad Methods fmap :: (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b # (<$) :: a0 -> Cokleisli w a b -> Cokleisli w a a0 #
Functor f => Functor (WhenMatched f x y) | Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # (<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Functor (WhenMissing f k x) | Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # (<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a #
Functor (ContT r m) |
Instance details Defined in Control.Monad.Trans.Cont Methods fmap :: (a -> b) -> ContT r m a -> ContT r m b # (<$) :: a -> ContT r m b -> ContT r m a #
Functor ((,,,) a b c) | Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) #
Functor ((->) r) | Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
(Functor f, Functor g) => Functor (Compose f g) | Since: base-4.9.0.0
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (f :.: g) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Functor f => Functor (M1 i c f) | Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor (Clown f a :: Type -> Type) |
Instance details Defined in Data.Bifunctor.Clown Methods fmap :: (a0 -> b) -> Clown f a a0 -> Clown f a b # (<$) :: a0 -> Clown f a b -> Clown f a a0 #
Bifunctor p => Functor (Flip p a) |
Instance details Defined in Data.Bifunctor.Flip Methods fmap :: (a0 -> b) -> Flip p a a0 -> Flip p a b # (<$) :: a0 -> Flip p a b -> Flip p a a0 #
Functor g => Functor (Joker g a) |
Instance details Defined in Data.Bifunctor.Joker Methods fmap :: (a0 -> b) -> Joker g a a0 -> Joker g a b # (<$) :: a0 -> Joker g a b -> Joker g a a0 #
Bifunctor p => Functor (WrappedBifunctor p a) |
Instance details Defined in Data.Bifunctor.Wrapped Methods fmap :: (a0 -> b) -> WrappedBifunctor p a a0 -> WrappedBifunctor p a b # (<$) :: a0 -> WrappedBifunctor p a b -> WrappedBifunctor p a a0 #
Functor f => Functor (WhenMatched f k x y) | Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # (<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a #
Functor m => Functor (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor m => Functor (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor m => Functor (RWST r w s m) |
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor ((,,,,) a b c d) | Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0) # (<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0) #
(Functor (f a), Functor (g a)) => Functor (Product f g a) |
Instance details Defined in Data.Bifunctor.Product Methods fmap :: (a0 -> b) -> Product f g a a0 -> Product f g a b # (<$) :: a0 -> Product f g a b -> Product f g a a0 #
(Functor (f a), Functor (g a)) => Functor (Sum f g a) |
Instance details Defined in Data.Bifunctor.Sum Methods fmap :: (a0 -> b) -> Sum f g a a0 -> Sum f g a b # (<$) :: a0 -> Sum f g a b -> Sum f g a a0 #
Functor ((,,,,,) a b c d e) | Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0) # (<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0) #
(Functor f, Bifunctor p) => Functor (Tannen f p a) |
Instance details Defined in Data.Bifunctor.Tannen Methods fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b # (<$) :: a0 -> Tannen f p a b -> Tannen f p a a0 #
Functor ((,,,,,,) a b c d e f) | Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0) # (<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0) #
(Bifunctor p, Functor g) => Functor (Biff p f g a) |
Instance details Defined in Data.Bifunctor.Biff Methods fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b # (<$) :: a0 -> Biff p f g a b -> Biff p f g a a0 #

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #

An infix synonym for `fmap`.

The name of this operator is an allusion to `$`. Note the similarities between their types:

     ($)  ::              (a -> b) ->   a ->   b
    (<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas `$` is function application, `<$>` is function application lifted over a `Functor`.

#### Examples

Expand

Convert from a ``Maybe` `Int`` to a ``Maybe` `String`` using `show`:

    >>> show <$> Nothing
    Nothing
    >>> show <$> Just 3
    Just "3"

Convert from an ``Either` `Int` `Int`` to an ``Either` `Int`` `String` using `show`:

    >>> show <$> Left 17
    Left 17
    >>> show <$> Right 17
    Right "17"

Double each element of a list:

    >>> (*2) <$> [1,2,3]
    [2,4,6]

Apply `even` to the second element of a pair:

    >>> even <$> (2,2)
    (2,True)

($>) :: Functor f => f a -> b -> f b infixl 4 #

Flipped version of `<$`.

#### Examples

Expand

Replace the contents of a ``Maybe` `Int`` with a constant `String`:

    >>> Nothing $> "foo"
    Nothing
    >>> Just 90210 $> "foo"
    Just "foo"

Replace the contents of an ``Either` `Int` `Int`` with a constant `String`, resulting in an ``Either` `Int` `String``:

    >>> Left 8675309 $> "foo"
    Left 8675309
    >>> Right 8675309 $> "foo"
    Right "foo"

Replace each element of a list with a constant `String`:

    >>> [1,2,3] $> "foo"
    ["foo","foo","foo"]

Replace the second element of a pair with a constant `String`:

    >>> (1,2) $> "foo"
    (1,"foo")

Since: base-4.7.0.0

# Apply - a strong lax semimonoidal endofunctor

class Functor f => Apply (f :: Type -> Type) where #

A strong lax semi-monoidal endofunctor. This is equivalent to an `Applicative` without `pure`.

Laws:

    (.) <$> u <.> v <.> w = u <.> (v <.> w)
    x <.> (f <$> y) = (. f) <$> x <.> y
    f <$> (x <.> y) = (f .) <$> x <.> y

The laws imply that `.>` and `<.` really ignore their left and right results, respectively, and really return their right and left results, respectively. Specifically,

    (mf <$> m) .> (nf <$> n) = nf <$> (m .> n)
    (mf <$> m) <. (nf <$> n) = mf <$> (m <. n)

Minimal complete definition

(<.>) | liftF2

Methods

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

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

     a .> b = const id <$> a <.> b

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

     a <. b = const <$> a <.> b

liftF2 :: (a -> b -> c) -> f a -> f b -> f c #

Lift a binary function into a comonad with zipping

#### Instances

Instances details

Apply ZipList # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b # (.>) :: ZipList a -> ZipList b -> ZipList b # (<.) :: ZipList a -> ZipList b -> ZipList a # liftF2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c #
Apply Complex # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Complex (a -> b) -> Complex a -> Complex b # (.>) :: Complex a -> Complex b -> Complex b # (<.) :: Complex a -> Complex b -> Complex a # liftF2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c #
Apply Identity # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b # (.>) :: Identity a -> Identity b -> Identity b # (<.) :: Identity a -> Identity b -> Identity a # liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c #
Apply First # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: First (a -> b) -> First a -> First b # (.>) :: First a -> First b -> First b # (<.) :: First a -> First b -> First a # liftF2 :: (a -> b -> c) -> First a -> First b -> First c #
Apply Last # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Last (a -> b) -> Last a -> Last b # (.>) :: Last a -> Last b -> Last b # (<.) :: Last a -> Last b -> Last a # liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c #
Apply Down # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Down (a -> b) -> Down a -> Down b # (.>) :: Down a -> Down b -> Down b # (<.) :: Down a -> Down b -> Down a # liftF2 :: (a -> b -> c) -> Down a -> Down b -> Down c #
Apply First # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: First (a -> b) -> First a -> First b # (.>) :: First a -> First b -> First b # (<.) :: First a -> First b -> First a # liftF2 :: (a -> b -> c) -> First a -> First b -> First c #
Apply Last # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Last (a -> b) -> Last a -> Last b # (.>) :: Last a -> Last b -> Last b # (<.) :: Last a -> Last b -> Last a # liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c #
Apply Max # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Max (a -> b) -> Max a -> Max b # (.>) :: Max a -> Max b -> Max b # (<.) :: Max a -> Max b -> Max a # liftF2 :: (a -> b -> c) -> Max a -> Max b -> Max c #
Apply Min # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Min (a -> b) -> Min a -> Min b # (.>) :: Min a -> Min b -> Min b # (<.) :: Min a -> Min b -> Min a # liftF2 :: (a -> b -> c) -> Min a -> Min b -> Min c #
Apply Dual # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Dual (a -> b) -> Dual a -> Dual b # (.>) :: Dual a -> Dual b -> Dual b # (<.) :: Dual a -> Dual b -> Dual a # liftF2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c #
Apply Product # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Product (a -> b) -> Product a -> Product b # (.>) :: Product a -> Product b -> Product b # (<.) :: Product a -> Product b -> Product a # liftF2 :: (a -> b -> c) -> Product a -> Product b -> Product c #
Apply Sum # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Sum (a -> b) -> Sum a -> Sum b # (.>) :: Sum a -> Sum b -> Sum b # (<.) :: Sum a -> Sum b -> Sum a # liftF2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c #
Apply NonEmpty # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # (.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a # liftF2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c #
Apply Par1 # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Par1 (a -> b) -> Par1 a -> Par1 b # (.>) :: Par1 a -> Par1 b -> Par1 b # (<.) :: Par1 a -> Par1 b -> Par1 a # liftF2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c #
Apply IntMap # | An `IntMap` is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IntMap (a -> b) -> IntMap a -> IntMap b # (.>) :: IntMap a -> IntMap b -> IntMap b # (<.) :: IntMap a -> IntMap b -> IntMap a # liftF2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c #
Apply Seq # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Seq (a -> b) -> Seq a -> Seq b # (.>) :: Seq a -> Seq b -> Seq b # (<.) :: Seq a -> Seq b -> Seq a # liftF2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c #
Apply Tree # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Tree (a -> b) -> Tree a -> Tree b # (.>) :: Tree a -> Tree b -> Tree b # (<.) :: Tree a -> Tree b -> Tree a # liftF2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c #
Apply IO # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IO (a -> b) -> IO a -> IO b # (.>) :: IO a -> IO b -> IO b # (<.) :: IO a -> IO b -> IO a # liftF2 :: (a -> b -> c) -> IO a -> IO b -> IO c #
Apply Q # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Q (a -> b) -> Q a -> Q b # (.>) :: Q a -> Q b -> Q b # (<.) :: Q a -> Q b -> Q a # liftF2 :: (a -> b -> c) -> Q a -> Q b -> Q c #
Apply Maybe # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (.>) :: Maybe a -> Maybe b -> Maybe b # (<.) :: Maybe a -> Maybe b -> Maybe a # liftF2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c #
Apply [] # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: [a -> b] -> [a] -> [b] # (.>) :: [a] -> [b] -> [b] # (<.) :: [a] -> [b] -> [a] # liftF2 :: (a -> b -> c) -> [a] -> [b] -> [c] #
Monad m => Apply (WrappedMonad m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # liftF2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c #
Apply (Either a) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Either a (a0 -> b) -> Either a a0 -> Either a b # (.>) :: Either a a0 -> Either a b -> Either a b # (<.) :: Either a a0 -> Either a b -> Either a a0 # liftF2 :: (a0 -> b -> c) -> Either a a0 -> Either a b -> Either a c #
Apply (Proxy :: Type -> Type) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Proxy (a -> b) -> Proxy a -> Proxy b # (.>) :: Proxy a -> Proxy b -> Proxy b # (<.) :: Proxy a -> Proxy b -> Proxy a # liftF2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c #
Apply (U1 :: Type -> Type) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: U1 (a -> b) -> U1 a -> U1 b # (.>) :: U1 a -> U1 b -> U1 b # (<.) :: U1 a -> U1 b -> U1 a # liftF2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c #
Apply (V1 :: Type -> Type) # | A `V1` is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: V1 (a -> b) -> V1 a -> V1 b # (.>) :: V1 a -> V1 b -> V1 b # (<.) :: V1 a -> V1 b -> V1 a # liftF2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c #
Ord k => Apply (Map k) # | A 'Map k' is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Map k (a -> b) -> Map k a -> Map k b # (.>) :: Map k a -> Map k b -> Map k b # (<.) :: Map k a -> Map k b -> Map k a # liftF2 :: (a -> b -> c) -> Map k a -> Map k b -> Map k c #
Apply f => Apply (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a # liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c #
Applicative f => Apply (WrappedApplicative f) # |

Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b #

(.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b #

(<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #

liftF2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c #

Apply f => Apply (Lift f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b # (.>) :: Lift f a -> Lift f b -> Lift f b # (<.) :: Lift f a -> Lift f b -> Lift f a # liftF2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c #
(Functor m, Monad m) => Apply (MaybeT m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # (.>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<.) :: MaybeT m a -> MaybeT m b -> MaybeT m a # liftF2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c #
(Hashable k, Eq k) => Apply (HashMap k) # | A 'HashMap k' is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: HashMap k (a -> b) -> HashMap k a -> HashMap k b # (.>) :: HashMap k a -> HashMap k b -> HashMap k b # (<.) :: HashMap k a -> HashMap k b -> HashMap k a # liftF2 :: (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c #
Semigroup m => Apply ((,) m) # | A ``(,)` m` is not `Applicative` unless its `m` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (m, a -> b) -> (m, a) -> (m, b) # (.>) :: (m, a) -> (m, b) -> (m, b) # (<.) :: (m, a) -> (m, b) -> (m, a) # liftF2 :: (a -> b -> c) -> (m, a) -> (m, b) -> (m, c) #
Arrow a => Apply (WrappedArrow a b) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (.>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<.) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # liftF2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c #
Semigroup m => Apply (Const m :: Type -> Type) # | A ``Const` m` is not `Applicative` unless its `m` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Const m (a -> b) -> Const m a -> Const m b # (.>) :: Const m a -> Const m b -> Const m b # (<.) :: Const m a -> Const m b -> Const m a # liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c #
Apply f => Apply (Alt f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Alt f (a -> b) -> Alt f a -> Alt f b # (.>) :: Alt f a -> Alt f b -> Alt f b # (<.) :: Alt f a -> Alt f b -> Alt f a # liftF2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c #
Apply f => Apply (Rec1 f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # (.>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<.) :: Rec1 f a -> Rec1 f b -> Rec1 f a # liftF2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c #
Biapply p => Apply (Join p) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Join p (a -> b) -> Join p a -> Join p b # (.>) :: Join p a -> Join p b -> Join p b # (<.) :: Join p a -> Join p b -> Join p a # liftF2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c #
(Semigroup e, Apply w) => Apply (EnvT e w) # | An ``EnvT` e w` is not `Applicative` unless its `e` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b # (.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b # (<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a # liftF2 :: (a -> b -> c) -> EnvT e w a -> EnvT e w b -> EnvT e w c #
(Apply w, Semigroup s) => Apply (StoreT s w) # | A ``StoreT` s w` is not `Applicative` unless its `s` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StoreT s w (a -> b) -> StoreT s w a -> StoreT s w b # (.>) :: StoreT s w a -> StoreT s w b -> StoreT s w b # (<.) :: StoreT s w a -> StoreT s w b -> StoreT s w a # liftF2 :: (a -> b -> c) -> StoreT s w a -> StoreT s w b -> StoreT s w c #
Apply w => Apply (TracedT m w) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b # (.>) :: TracedT m w a -> TracedT m w b -> TracedT m w b # (<.) :: TracedT m w a -> TracedT m w b -> TracedT m w a # liftF2 :: (a -> b -> c) -> TracedT m w a -> TracedT m w b -> TracedT m w c #
Apply f => Apply (Static f a) # |
Instance details Defined in Data.Semigroupoid.Static Methods (<.>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b # (.>) :: Static f a a0 -> Static f a b -> Static f a b # (<.) :: Static f a a0 -> Static f a b -> Static f a a0 # liftF2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c #
Apply (Tagged a) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Tagged a (a0 -> b) -> Tagged a a0 -> Tagged a b # (.>) :: Tagged a a0 -> Tagged a b -> Tagged a b # (<.) :: Tagged a a0 -> Tagged a b -> Tagged a a0 # liftF2 :: (a0 -> b -> c) -> Tagged a a0 -> Tagged a b -> Tagged a c #
Apply f => Apply (Backwards f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b # (.>) :: Backwards f a -> Backwards f b -> Backwards f b # (<.) :: Backwards f a -> Backwards f b -> Backwards f a # liftF2 :: (a -> b -> c) -> Backwards f a -> Backwards f b -> Backwards f c #
(Functor m, Monad m) => Apply (ExceptT e m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # (.>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<.) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a # liftF2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c #
Apply w => Apply (IdentityT w) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b # (.>) :: IdentityT w a -> IdentityT w b -> IdentityT w b # (<.) :: IdentityT w a -> IdentityT w b -> IdentityT w a # liftF2 :: (a -> b -> c) -> IdentityT w a -> IdentityT w b -> IdentityT w c #
Apply m => Apply (ReaderT e m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ReaderT e m (a -> b) -> ReaderT e m a -> ReaderT e m b # (.>) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m b # (<.) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m a # liftF2 :: (a -> b -> c) -> ReaderT e m a -> ReaderT e m b -> ReaderT e m c #
Bind m => Apply (StateT s m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # (.>) :: StateT s m a -> StateT s m b -> StateT s m b # (<.) :: StateT s m a -> StateT s m b -> StateT s m a # liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c #
Bind m => Apply (StateT s m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # (.>) :: StateT s m a -> StateT s m b -> StateT s m b # (<.) :: StateT s m a -> StateT s m b -> StateT s m a # liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c #
Bind m => Apply (WriterT w m) # | Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c #
(Apply m, Semigroup w) => Apply (WriterT w m) # | A ``WriterT` w m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c #
(Apply m, Semigroup w) => Apply (WriterT w m) # | A ``WriterT` w m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c #
Semigroup f => Apply (Constant f :: Type -> Type) # | A ``Constant` f` is not `Applicative` unless its `f` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Constant f (a -> b) -> Constant f a -> Constant f b # (.>) :: Constant f a -> Constant f b -> Constant f b # (<.) :: Constant f a -> Constant f b -> Constant f a # liftF2 :: (a -> b -> c) -> Constant f a -> Constant f b -> Constant f c #
Apply f => Apply (Reverse f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Reverse f (a -> b) -> Reverse f a -> Reverse f b # (.>) :: Reverse f a -> Reverse f b -> Reverse f b # (<.) :: Reverse f a -> Reverse f b -> Reverse f a # liftF2 :: (a -> b -> c) -> Reverse f a -> Reverse f b -> Reverse f c #
(Apply f, Apply g) => Apply (Product f g) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Product f g (a -> b) -> Product f g a -> Product f g b # (.>) :: Product f g a -> Product f g b -> Product f g b # (<.) :: Product f g a -> Product f g b -> Product f g a # liftF2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c #
(Apply f, Apply g) => Apply (f :*: g) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b # (.>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # (<.) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a # liftF2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c #
Semigroup c => Apply (K1 i c :: Type -> Type) # | A ``K1` i c` is not `Applicative` unless its `c` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # (.>) :: K1 i c a -> K1 i c b -> K1 i c b # (<.) :: K1 i c a -> K1 i c b -> K1 i c a # liftF2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 #
Apply (Cokleisli w a) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b # (.>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b # (<.) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0 # liftF2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c #
Apply (ContT r m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b # (.>) :: ContT r m a -> ContT r m b -> ContT r m b # (<.) :: ContT r m a -> ContT r m b -> ContT r m a # liftF2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c #
Apply ((->) m) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (m -> (a -> b)) -> (m -> a) -> m -> b # (.>) :: (m -> a) -> (m -> b) -> m -> b # (<.) :: (m -> a) -> (m -> b) -> m -> a # liftF2 :: (a -> b -> c) -> (m -> a) -> (m -> b) -> m -> c #
(Apply f, Apply g) => Apply (Compose f g) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b # (.>) :: Compose f g a -> Compose f g b -> Compose f g b # (<.) :: Compose f g a -> Compose f g b -> Compose f g a # liftF2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c #
(Apply f, Apply g) => Apply (f :.: g) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # (.>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<.) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a # liftF2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c #
Apply f => Apply (M1 i t f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: M1 i t f (a -> b) -> M1 i t f a -> M1 i t f b # (.>) :: M1 i t f a -> M1 i t f b -> M1 i t f b # (<.) :: M1 i t f a -> M1 i t f b -> M1 i t f a # liftF2 :: (a -> b -> c) -> M1 i t f a -> M1 i t f b -> M1 i t f c #
Bind m => Apply (RWST r w s m) # | Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # (.>) :: 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 # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c #
(Bind m, Semigroup w) => Apply (RWST r w s m) # | An ``RWST` r w s m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # (.>) :: 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 # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c #
(Bind m, Semigroup w) => Apply (RWST r w s m) # | An ``RWST` r w s m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # (.>) :: 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 # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c #

(<..>) :: Apply w => w a -> w (a -> b) -> w b infixl 4 #

A variant of `<.>` with the arguments reversed.

liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d #

Lift a ternary function into a comonad with zipping

gliftF2 :: (Generic1 w, Apply (Rep1 w)) => (a -> b -> c) -> w a -> w b -> w c #

Generic `liftF2`. Caveats:

1. Will not compile if `w` is a sum type.
2. Types in `w` that do not mention the type variable must be instances of `Semigroup`.

Since: 5.3.8

gliftF3 :: (Generic1 w, Apply (Rep1 w)) => (a -> b -> c -> d) -> w a -> w b -> w c -> w d #

Generic `liftF3`. Caveats are the same as for `gliftF2`.

Since: 5.3.8

# Wrappers

newtype WrappedApplicative (f :: Type -> Type) a #

Wrap an `Applicative` to be used as a member of `Apply`

Constructors

WrapApplicative |

Fields

- unwrapApplicative :: f a

#### Instances

Instances details

Alternative f => Alternative (WrappedApplicative f) # |
Instance details Defined in Data.Functor.Bind.Class Methods empty :: WrappedApplicative f a # (<|>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a # some :: WrappedApplicative f a -> WrappedApplicative f [a] # many :: WrappedApplicative f a -> WrappedApplicative f [a] #
Applicative f => Applicative (WrappedApplicative f) # |

Instance details

Defined in Data.Functor.Bind.Class

Methods

pure :: a -> WrappedApplicative f a #

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

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

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

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

Functor f => Functor (WrappedApplicative f) # |
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a #
Alternative f => Alt (WrappedApplicative f) # |
Instance details Defined in Data.Functor.Alt Methods (<!>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a # some :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] # many :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] #
Applicative f => Apply (WrappedApplicative f) # |

Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b #

(.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b #

(<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #

liftF2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c #

Alternative f => Plus (WrappedApplicative f) # |
Instance details Defined in Data.Functor.Plus Methods zero :: WrappedApplicative f a #

newtype MaybeApply (f :: Type -> Type) a #

Transform an Apply into an Applicative by adding a unit.

Constructors

MaybeApply |

Fields

- runMaybeApply :: Either (f a) a

#### Instances

Instances details

Apply f => Applicative (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods pure :: a -> MaybeApply f a # (<*>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # liftA2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c # (*>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<*) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a #
Functor f => Functor (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b # (<$) :: a -> MaybeApply f b -> MaybeApply f a #
Comonad f => Comonad (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods extract :: MaybeApply f a -> a # duplicate :: MaybeApply f a -> MaybeApply f (MaybeApply f a) # extend :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b #
Apply f => Apply (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a # liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c #
Extend f => Extend (MaybeApply f) # |
Instance details Defined in Data.Functor.Bind.Class Methods duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a) # extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b #

(<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b infixl 4 #

Apply a non-empty container of functions to a possibly-empty-with-unit container of values.

(<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b infixl 4 #

Apply a possibly-empty-with-unit container of functions to a non-empty container of values.