Data.Functor.Apply

Functors

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

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Methods

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

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

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

Instances

Functor []

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor Par1

Defined in GHC.Generics

Methods

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

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

Functor Q

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Functor Complex

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

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

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

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

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

Defined in Data.Semigroup

Methods

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

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

Functor ZipList

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

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

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

Defined in GHC.Conc.Sync

Methods

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

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

Functor First

Defined in Data.Monoid

Methods

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

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

Functor Last

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

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

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

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

Defined in Data.Ord

Methods

fmap :: (a -> b) -> Down a -> Down b

(<$) :: a -> Down b -> Down a

Functor ReadP

Since: base-2.1

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

Defined in GHC.Base

Methods

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

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

Functor IntMap

Defined in Data.IntMap.Internal

Methods

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

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

Functor Tree

Defined in Data.Tree

Methods

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

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

Functor Seq

Defined in Data.Sequence.Internal

Methods

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

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

Functor FingerTree

Defined in Data.Sequence.Internal

Methods

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

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

Functor Digit

Defined in Data.Sequence.Internal

Methods

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

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

Functor Node

Defined in Data.Sequence.Internal

Methods

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

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

Functor Elem

Defined in Data.Sequence.Internal

Methods

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

(<$) :: a -> Elem b -> Elem a

Functor ViewL

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewL a -> ViewL b

(<$) :: a -> ViewL b -> ViewL a

Functor ViewR

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewR a -> ViewR b

(<$) :: a -> ViewR b -> ViewR a

Functor Doc

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

(<$) :: a -> Doc b -> Doc a

Functor AnnotDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b

(<$) :: a -> AnnotDetails b -> AnnotDetails a

Functor Span

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

(<$) :: a -> Span b -> Span a

Functor P

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

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (V1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor (U1 :: * -> *)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor ((,) a)

Since: base-2.1

Defined in GHC.Base

Methods

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

(<$) :: a0 -> (a, b) -> (a, a0)

Functor (Array i)

Since: base-2.1

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

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

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

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

(<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0

Functor (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

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

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

Functor (Map k)

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)

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)

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)

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)

Defined in Data.HashMap.Base

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b

(<$) :: a -> HashMap k b -> HashMap k a

Functor f => Functor (MaybeApply f)

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)

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)

Defined in GHC.Generics

Methods

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

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

Functor (URec Char :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Functor (URec (Ptr ()) :: * -> *)

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Arrow a => Functor (WrappedArrow a b)

Since: base-2.1

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

Since: base-2.1

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 (Alt f)

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)

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)

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)

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)

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)

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

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)

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.

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

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)

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)

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)

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)

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 (ExceptT e m)

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)

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.

Defined in Control.Applicative.Backwards

Methods

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

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

Functor f => Functor (Static f a)

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

Since: base-2.1

Defined in GHC.Base

Methods

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

(<$) :: a -> (r -> b) -> r -> a

Functor (K1 i c :: * -> *)

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)

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)

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 (Product f g)

Since: base-4.9.0.0

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

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)

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

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

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 m => Functor (ReaderT r m)

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 (ContT r m)

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)

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)

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

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)

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)

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)

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

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

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)

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)

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)

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)

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

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

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

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

Apply []

Defined in Data.Functor.Bind.Class

Methods

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

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

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

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

Apply Maybe

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 IO

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 Par1

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 Q

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 Complex

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 Min

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 Max

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 First

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

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 Option

Defined in Data.Functor.Bind.Class

Methods

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

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

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

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

Apply ZipList

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 Identity

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

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

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 Dual

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 Sum

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 Product

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 Down

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 NonEmpty

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 IntMap

An IntMap is not Applicative, but it is an instance of Apply

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 Tree

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 Seq

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 (Either a)

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

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

Apply (U1 :: * -> *)

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

Semigroup m => Apply ((,) m)

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)

Monad m => Apply (WrappedMonad m)

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

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

Ord k => Apply (Map k)

A Map is not Applicative, but it is an instance of Apply

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 (Lift f)

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)

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

Apply m => Apply (ListT m)

Defined in Data.Functor.Bind.Class

Methods

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

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

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

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

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

A HashMap is not Applicative, but it is an instance of Apply

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

Apply f => Apply (MaybeApply f)

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)

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 (Rec1 f)

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

Arrow a => Apply (WrappedArrow a b)

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

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)

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

Biapply p => Apply (Join p)

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

Apply w => Apply (TracedT m w)

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 w, Semigroup s) => Apply (StoreT s w)

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

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

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 => Apply (IdentityT w)

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 (Tagged a)

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 (Reverse f)

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

Semigroup f => Apply (Constant f :: * -> *)

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 m, Semigroup w) => Apply (WriterT w m)

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)

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

Bind m => Apply (StateT s m)

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)

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

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

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

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

Defined in Data.Functor.Bind.Class

Methods

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

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

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

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

Apply f => Apply (Backwards f)

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

Apply f => Apply (Static f a)

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

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

Semigroup c => Apply (K1 i c :: * -> *)

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 f, Apply g) => Apply (f :*: g)

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 g) => Apply (Product f g)

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 (Cokleisli w a)

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 m => Apply (ReaderT e m)

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

Apply (ContT r m)

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

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

(Apply f, Apply g) => Apply (f :.: g)

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 g) => Apply (Compose f g)

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

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

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)

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

Wrappers

newtype WrappedApplicative f a

Wrap an Applicative to be used as a member of Apply

Constructors

WrapApplicative

Fields

• unwrapApplicative :: f a

Instances

Functor f => Functor (WrappedApplicative f)

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)

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

Alternative f => Alternative (WrappedApplicative f)

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 => Apply (WrappedApplicative f)

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 => Alt (WrappedApplicative f)

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]

Alternative f => Plus (WrappedApplicative f)

Defined in Data.Functor.Plus

Methods

zero :: WrappedApplicative f a

newtype MaybeApply f a

Transform a Apply into an Applicative by adding a unit.

Constructors

MaybeApply

Fields

• runMaybeApply :: Either (f a) a

Instances

Functor f => Functor (MaybeApply f)

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)

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)

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)

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

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