semigroupoids-5.3.5: Semigroupoids: Category sans id
Copyright(C) 2011-2015 Edward Kmett
LicenseBSD-style (see the file LICENSE)
MaintainerEdward Kmett <ekmett@gmail.com>
Stabilityprovisional
Portabilityportable
Safe HaskellTrustworthy
LanguageHaskell2010

Data.Functor.Apply

Description

 
Synopsis

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.

Minimal complete definition

fmap

Methods

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

Using ApplicativeDo: 'fmap f as' can be understood as the do expression

do a <- as
   pure (f a)

with an inferred Functor constraint.

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

Using ApplicativeDo: 'a <$ bs' can be understood as the do expression

do bs
   pure a

with an inferred Functor constraint.

Instances

Instances details
Functor []

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

fmap :: (a -> b) -> [a] -> [b] #

(<$) :: a -> [b] -> [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 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 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 Q 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

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

(<$) :: a -> Q b -> Q 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 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 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 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 Option

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

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

(<$) :: a -> Option b -> Option a #

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 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 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 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 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 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 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 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 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 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 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 IntMap 
Instance details

Defined in Data.IntMap.Internal

Methods

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

(<$) :: a -> IntMap b -> IntMap a #

Functor Tree 
Instance details

Defined in Data.Tree

Methods

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

(<$) :: a -> Tree b -> Tree a #

Functor Seq 
Instance details

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> Seq b -> Seq a #

Functor FingerTree 
Instance details

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> FingerTree b -> FingerTree a #

Functor Digit 
Instance details

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> Digit b -> Digit a #

Functor Node 
Instance details

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> Node b -> Node a #

Functor Elem 
Instance details

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> Elem b -> Elem 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 Doc 
Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

(<$) :: a -> Doc b -> Doc 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 Span 
Instance details

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

(<$) :: a -> Span b -> Span 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 (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 (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 (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 ((,) a)

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

fmap :: (a0 -> b) -> (a, a0) -> (a, b) #

(<$) :: a0 -> (a, b) -> (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 (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 #

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 (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 (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 (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 m => Functor (ListT m) 
Instance details

Defined in Control.Monad.Trans.List

Methods

fmap :: (a -> b) -> ListT m a -> ListT m b #

(<$) :: a -> ListT m b -> ListT 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 f => Functor (MaybeApply f) Source # 
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) Source # 
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 (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 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 (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 ((,,) 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) #

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 #

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 (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 #

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 (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 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 #

(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 #

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 (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 (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 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 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 (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 (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 (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 (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 (ErrorT e m) 
Instance details

Defined in Control.Monad.Trans.Error

Methods

fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b #

(<$) :: a -> ErrorT e m b -> ErrorT e m 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 (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 f => Functor (Static f a) Source # 
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 ((->) r :: Type -> Type)

Since: base-2.1

Instance details

Defined in GHC.Base

Methods

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

(<$) :: a -> (r -> b) -> r -> 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 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 ((,,,) 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 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 (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 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 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 (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 #

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 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 (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 (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 #

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.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 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 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 #

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

Using ApplicativeDo: 'as $> b' can be understood as the do expression

do as
   pure b

with an inferred Functor constraint.

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 where Source #

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 Source #

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

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

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

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

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

Lift a binary function into a comonad with zipping

Instances

Instances details
Apply [] Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: [a -> b] -> [a] -> [b] Source #

(.>) :: [a] -> [b] -> [b] Source #

(<.) :: [a] -> [b] -> [a] Source #

liftF2 :: (a -> b -> c) -> [a] -> [b] -> [c] Source #

Apply Maybe Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source #

(.>) :: Maybe a -> Maybe b -> Maybe b Source #

(<.) :: Maybe a -> Maybe b -> Maybe a Source #

liftF2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source #

Apply IO Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IO (a -> b) -> IO a -> IO b Source #

(.>) :: IO a -> IO b -> IO b Source #

(<.) :: IO a -> IO b -> IO a Source #

liftF2 :: (a -> b -> c) -> IO a -> IO b -> IO c Source #

Apply Par1 Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source #

(.>) :: Par1 a -> Par1 b -> Par1 b Source #

(<.) :: Par1 a -> Par1 b -> Par1 a Source #

liftF2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source #

Apply Q Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Q (a -> b) -> Q a -> Q b Source #

(.>) :: Q a -> Q b -> Q b Source #

(<.) :: Q a -> Q b -> Q a Source #

liftF2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source #

Apply Complex Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Complex (a -> b) -> Complex a -> Complex b Source #

(.>) :: Complex a -> Complex b -> Complex b Source #

(<.) :: Complex a -> Complex b -> Complex a Source #

liftF2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c Source #

Apply Min Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Min (a -> b) -> Min a -> Min b Source #

(.>) :: Min a -> Min b -> Min b Source #

(<.) :: Min a -> Min b -> Min a Source #

liftF2 :: (a -> b -> c) -> Min a -> Min b -> Min c Source #

Apply Max Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Max (a -> b) -> Max a -> Max b Source #

(.>) :: Max a -> Max b -> Max b Source #

(<.) :: Max a -> Max b -> Max a Source #

liftF2 :: (a -> b -> c) -> Max a -> Max b -> Max c Source #

Apply First Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: First (a -> b) -> First a -> First b Source #

(.>) :: First a -> First b -> First b Source #

(<.) :: First a -> First b -> First a Source #

liftF2 :: (a -> b -> c) -> First a -> First b -> First c Source #

Apply Last Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Last (a -> b) -> Last a -> Last b Source #

(.>) :: Last a -> Last b -> Last b Source #

(<.) :: Last a -> Last b -> Last a Source #

liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source #

Apply Option Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Option (a -> b) -> Option a -> Option b Source #

(.>) :: Option a -> Option b -> Option b Source #

(<.) :: Option a -> Option b -> Option a Source #

liftF2 :: (a -> b -> c) -> Option a -> Option b -> Option c Source #

Apply ZipList Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source #

(.>) :: ZipList a -> ZipList b -> ZipList b Source #

(<.) :: ZipList a -> ZipList b -> ZipList a Source #

liftF2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c Source #

Apply Identity Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Identity (a -> b) -> Identity a -> Identity b Source #

(.>) :: Identity a -> Identity b -> Identity b Source #

(<.) :: Identity a -> Identity b -> Identity a Source #

liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source #

Apply First Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: First (a -> b) -> First a -> First b Source #

(.>) :: First a -> First b -> First b Source #

(<.) :: First a -> First b -> First a Source #

liftF2 :: (a -> b -> c) -> First a -> First b -> First c Source #

Apply Last Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Last (a -> b) -> Last a -> Last b Source #

(.>) :: Last a -> Last b -> Last b Source #

(<.) :: Last a -> Last b -> Last a Source #

liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source #

Apply Dual Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Dual (a -> b) -> Dual a -> Dual b Source #

(.>) :: Dual a -> Dual b -> Dual b Source #

(<.) :: Dual a -> Dual b -> Dual a Source #

liftF2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source #

Apply Sum Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Sum (a -> b) -> Sum a -> Sum b Source #

(.>) :: Sum a -> Sum b -> Sum b Source #

(<.) :: Sum a -> Sum b -> Sum a Source #

liftF2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source #

Apply Product Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Product (a -> b) -> Product a -> Product b Source #

(.>) :: Product a -> Product b -> Product b Source #

(<.) :: Product a -> Product b -> Product a Source #

liftF2 :: (a -> b -> c) -> Product a -> Product b -> Product c Source #

Apply Down Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Down (a -> b) -> Down a -> Down b Source #

(.>) :: Down a -> Down b -> Down b Source #

(<.) :: Down a -> Down b -> Down a Source #

liftF2 :: (a -> b -> c) -> Down a -> Down b -> Down c Source #

Apply NonEmpty Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source #

(.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source #

(<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source #

liftF2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source #

Apply IntMap Source #

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 Source #

(.>) :: IntMap a -> IntMap b -> IntMap b Source #

(<.) :: IntMap a -> IntMap b -> IntMap a Source #

liftF2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c Source #

Apply Tree Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Tree (a -> b) -> Tree a -> Tree b Source #

(.>) :: Tree a -> Tree b -> Tree b Source #

(<.) :: Tree a -> Tree b -> Tree a Source #

liftF2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c Source #

Apply Seq Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Seq (a -> b) -> Seq a -> Seq b Source #

(.>) :: Seq a -> Seq b -> Seq b Source #

(<.) :: Seq a -> Seq b -> Seq a Source #

liftF2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source #

Apply (Either a) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Either a (a0 -> b) -> Either a a0 -> Either a b Source #

(.>) :: Either a a0 -> Either a b -> Either a b Source #

(<.) :: Either a a0 -> Either a b -> Either a a0 Source #

liftF2 :: (a0 -> b -> c) -> Either a a0 -> Either a b -> Either a c Source #

Apply (V1 :: Type -> Type) Source #

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 Source #

(.>) :: V1 a -> V1 b -> V1 b Source #

(<.) :: V1 a -> V1 b -> V1 a Source #

liftF2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c Source #

Apply (U1 :: Type -> Type) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: U1 (a -> b) -> U1 a -> U1 b Source #

(.>) :: U1 a -> U1 b -> U1 b Source #

(<.) :: U1 a -> U1 b -> U1 a Source #

liftF2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source #

Semigroup m => Apply ((,) m) Source #

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) Source #

(.>) :: (m, a) -> (m, b) -> (m, b) Source #

(<.) :: (m, a) -> (m, b) -> (m, a) Source #

liftF2 :: (a -> b -> c) -> (m, a) -> (m, b) -> (m, c) Source #

Monad m => Apply (WrappedMonad m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source #

(.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source #

(<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source #

liftF2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source #

Apply (Proxy :: Type -> Type) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Proxy (a -> b) -> Proxy a -> Proxy b Source #

(.>) :: Proxy a -> Proxy b -> Proxy b Source #

(<.) :: Proxy a -> Proxy b -> Proxy a Source #

liftF2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source #

Ord k => Apply (Map k) Source #

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 Source #

(.>) :: Map k a -> Map k b -> Map k b Source #

(<.) :: Map k a -> Map k b -> Map k a Source #

liftF2 :: (a -> b -> c) -> Map k a -> Map k b -> Map k c Source #

Apply f => Apply (Lift f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b Source #

(.>) :: Lift f a -> Lift f b -> Lift f b Source #

(<.) :: Lift f a -> Lift f b -> Lift f a Source #

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

(Functor m, Monad m) => Apply (MaybeT m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b Source #

(.>) :: MaybeT m a -> MaybeT m b -> MaybeT m b Source #

(<.) :: MaybeT m a -> MaybeT m b -> MaybeT m a Source #

liftF2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c Source #

Apply m => Apply (ListT m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ListT m (a -> b) -> ListT m a -> ListT m b Source #

(.>) :: ListT m a -> ListT m b -> ListT m b Source #

(<.) :: ListT m a -> ListT m b -> ListT m a Source #

liftF2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c Source #

(Hashable k, Eq k) => Apply (HashMap k) Source #

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 Source #

(.>) :: HashMap k a -> HashMap k b -> HashMap k b Source #

(<.) :: HashMap k a -> HashMap k b -> HashMap k a Source #

liftF2 :: (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c Source #

Apply f => Apply (MaybeApply f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b Source #

(.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b Source #

(<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a Source #

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

Applicative f => Apply (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Apply f => Apply (Rec1 f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source #

(.>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source #

(<.) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source #

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

Arrow a => Apply (WrappedArrow a b) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source #

(.>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source #

(<.) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source #

liftF2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source #

Semigroup m => Apply (Const m :: Type -> Type) Source #

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 Source #

(.>) :: Const m a -> Const m b -> Const m b Source #

(<.) :: Const m a -> Const m b -> Const m a Source #

liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source #

Apply f => Apply (Alt f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Alt f (a -> b) -> Alt f a -> Alt f b Source #

(.>) :: Alt f a -> Alt f b -> Alt f b Source #

(<.) :: Alt f a -> Alt f b -> Alt f a Source #

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

Biapply p => Apply (Join p) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Join p (a -> b) -> Join p a -> Join p b Source #

(.>) :: Join p a -> Join p b -> Join p b Source #

(<.) :: Join p a -> Join p b -> Join p a Source #

liftF2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c Source #

Apply w => Apply (TracedT m w) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b Source #

(.>) :: TracedT m w a -> TracedT m w b -> TracedT m w b Source #

(<.) :: TracedT m w a -> TracedT m w b -> TracedT m w a Source #

liftF2 :: (a -> b -> c) -> TracedT m w a -> TracedT m w b -> TracedT m w c Source #

(Apply w, Semigroup s) => Apply (StoreT s w) Source #

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 Source #

(.>) :: StoreT s w a -> StoreT s w b -> StoreT s w b Source #

(<.) :: StoreT s w a -> StoreT s w b -> StoreT s w a Source #

liftF2 :: (a -> b -> c) -> StoreT s w a -> StoreT s w b -> StoreT s w c Source #

(Semigroup e, Apply w) => Apply (EnvT e w) Source #

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 Source #

(.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b Source #

(<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a Source #

liftF2 :: (a -> b -> c) -> EnvT e w a -> EnvT e w b -> EnvT e w c Source #

Apply w => Apply (IdentityT w) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b Source #

(.>) :: IdentityT w a -> IdentityT w b -> IdentityT w b Source #

(<.) :: IdentityT w a -> IdentityT w b -> IdentityT w a Source #

liftF2 :: (a -> b -> c) -> IdentityT w a -> IdentityT w b -> IdentityT w c Source #

Apply (Tagged a) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Tagged a (a0 -> b) -> Tagged a a0 -> Tagged a b Source #

(.>) :: Tagged a a0 -> Tagged a b -> Tagged a b Source #

(<.) :: Tagged a a0 -> Tagged a b -> Tagged a a0 Source #

liftF2 :: (a0 -> b -> c) -> Tagged a a0 -> Tagged a b -> Tagged a c Source #

Apply f => Apply (Reverse f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Reverse f (a -> b) -> Reverse f a -> Reverse f b Source #

(.>) :: Reverse f a -> Reverse f b -> Reverse f b Source #

(<.) :: Reverse f a -> Reverse f b -> Reverse f a Source #

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

Semigroup f => Apply (Constant f :: Type -> Type) Source #

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 Source #

(.>) :: Constant f a -> Constant f b -> Constant f b Source #

(<.) :: Constant f a -> Constant f b -> Constant f a Source #

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

(Apply m, Semigroup w) => Apply (WriterT w m) Source #

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 Source #

(.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source #

(<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source #

liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source #

(Apply m, Semigroup w) => Apply (WriterT w m) Source #

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 Source #

(.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source #

(<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source #

liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source #

Bind m => Apply (StateT s m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source #

(.>) :: StateT s m a -> StateT s m b -> StateT s m b Source #

(<.) :: StateT s m a -> StateT s m b -> StateT s m a Source #

liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source #

Bind m => Apply (StateT s m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source #

(.>) :: StateT s m a -> StateT s m b -> StateT s m b Source #

(<.) :: StateT s m a -> StateT s m b -> StateT s m a Source #

liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source #

Apply m => Apply (ReaderT e m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ReaderT e m (a -> b) -> ReaderT e m a -> ReaderT e m b Source #

(.>) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m b Source #

(<.) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m a Source #

liftF2 :: (a -> b -> c) -> ReaderT e m a -> ReaderT e m b -> ReaderT e m c Source #

(Functor m, Monad m) => Apply (ExceptT e m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b Source #

(.>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source #

(<.) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a Source #

liftF2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c Source #

(Functor m, Monad m) => Apply (ErrorT e m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b Source #

(.>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source #

(<.) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a Source #

liftF2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c Source #

Apply f => Apply (Backwards f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b Source #

(.>) :: Backwards f a -> Backwards f b -> Backwards f b Source #

(<.) :: Backwards f a -> Backwards f b -> Backwards f a Source #

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

Apply f => Apply (Static f a) Source # 
Instance details

Defined in Data.Semigroupoid.Static

Methods

(<.>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b Source #

(.>) :: Static f a a0 -> Static f a b -> Static f a b Source #

(<.) :: Static f a a0 -> Static f a b -> Static f a a0 Source #

liftF2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c Source #

Apply ((->) m :: Type -> Type) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (m -> (a -> b)) -> (m -> a) -> m -> b Source #

(.>) :: (m -> a) -> (m -> b) -> m -> b Source #

(<.) :: (m -> a) -> (m -> b) -> m -> a Source #

liftF2 :: (a -> b -> c) -> (m -> a) -> (m -> b) -> m -> c Source #

Semigroup c => Apply (K1 i c :: Type -> Type) Source #

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 Source #

(.>) :: K1 i c a -> K1 i c b -> K1 i c b Source #

(<.) :: K1 i c a -> K1 i c b -> K1 i c a Source #

liftF2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 Source #

(Apply f, Apply g) => Apply (f :*: g) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

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

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

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

liftF2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c Source #

(Apply f, Apply g) => Apply (Product f g) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source #

(.>) :: Product f g a -> Product f g b -> Product f g b Source #

(<.) :: Product f g a -> Product f g b -> Product f g a Source #

liftF2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source #

Apply (Cokleisli w a) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b Source #

(.>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b Source #

(<.) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0 Source #

liftF2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c Source #

Apply (ContT r m) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b Source #

(.>) :: ContT r m a -> ContT r m b -> ContT r m b Source #

(<.) :: ContT r m a -> ContT r m b -> ContT r m a Source #

liftF2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c Source #

Apply f => Apply (M1 i t f) Source # 
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 Source #

(.>) :: M1 i t f a -> M1 i t f b -> M1 i t f b Source #

(<.) :: M1 i t f a -> M1 i t f b -> M1 i t f a Source #

liftF2 :: (a -> b -> c) -> M1 i t f a -> M1 i t f b -> M1 i t f c Source #

(Apply f, Apply g) => Apply (f :.: g) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source #

(.>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source #

(<.) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source #

liftF2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c Source #

(Apply f, Apply g) => Apply (Compose f g) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source #

(.>) :: Compose f g a -> Compose f g b -> Compose f g b Source #

(<.) :: Compose f g a -> Compose f g b -> Compose f g a Source #

liftF2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source #

(Bind m, Semigroup w) => Apply (RWST r w s m) Source #

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 Source #

(.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source #

(<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source #

liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source #

(Bind m, Semigroup w) => Apply (RWST r w s m) Source #

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 Source #

(.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source #

(<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source #

liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source #

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

A variant of <.> with the arguments reversed.

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

Lift a ternary function into a comonad with zipping

Wrappers

newtype WrappedApplicative f a Source #

Wrap an Applicative to be used as a member of Apply

Constructors

WrapApplicative 

Fields

Instances

Instances details
Functor f => Functor (WrappedApplicative f) Source # 
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 #

Applicative f => Applicative (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Alternative f => Alternative (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Applicative f => Apply (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Alternative f => Alt (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Alt

Alternative f => Plus (WrappedApplicative f) Source # 
Instance details

Defined in Data.Functor.Plus

newtype MaybeApply f a Source #

Transform an Apply into an Applicative by adding a unit.

Constructors

MaybeApply 

Fields

Instances

Instances details
Functor f => Functor (MaybeApply f) Source # 
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 #

Apply f => Applicative (MaybeApply f) Source # 
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 #

Comonad f => Comonad (MaybeApply f) Source # 
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 #

Extend f => Extend (MaybeApply f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a) Source #

extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b Source #

Apply f => Apply (MaybeApply f) Source # 
Instance details

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b Source #

(.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b Source #

(<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a Source #

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