Control.Comonad

Comonads

class Functor w => Comonad w where

There are two ways to define a comonad:

I. Provide definitions for extract and extend satisfying these laws:

extend extract      = id
extract . extend f  = f
extend f . extend g = extend (f . extend g)

In this case, you may simply set fmap = liftW.

These laws are directly analogous to the laws for monads and perhaps can be made clearer by viewing them as laws stating that Cokleisli composition must be associative, and has extract for a unit:

f =>= extract   = f
extract =>= f   = f
(f =>= g) =>= h = f =>= (g =>= h)

II. Alternately, you may choose to provide definitions for fmap, extract, and duplicate satisfying these laws:

extract . duplicate      = id
fmap extract . duplicate = id
duplicate . duplicate    = fmap duplicate . duplicate

In this case you may not rely on the ability to define fmap in terms of liftW.

You may of course, choose to define both duplicate and extend. In that case you must also satisfy these laws:

extend f  = fmap f . duplicate
duplicate = extend id
fmap f    = extend (f . extract)

These are the default definitions of extend and duplicate and the definition of liftW respectively.

Minimal complete definition

extract, (duplicate | extend)

Methods

extract :: w a -> a

extract . fmap f = f . extract

duplicate :: w a -> w (w a)

duplicate = extend id
fmap (fmap f) . duplicate = duplicate . fmap f

extend :: (w a -> b) -> w a -> w b

extend f = fmap f . duplicate

Instances

Comonad Identity

Defined in Control.Comonad

Methods

extract :: Identity a -> a

duplicate :: Identity a -> Identity (Identity a)

extend :: (Identity a -> b) -> Identity a -> Identity b

Comonad NonEmpty

Defined in Control.Comonad

Methods

extract :: NonEmpty a -> a

duplicate :: NonEmpty a -> NonEmpty (NonEmpty a)

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

Comonad Tree

Defined in Control.Comonad

Methods

extract :: Tree a -> a

duplicate :: Tree a -> Tree (Tree a)

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

Comonad ((,) e)

Defined in Control.Comonad

Methods

extract :: (e, a) -> a

duplicate :: (e, a) -> (e, (e, a))

extend :: ((e, a) -> b) -> (e, a) -> (e, b)

Comonad (Arg e)

Defined in Control.Comonad

Methods

extract :: Arg e a -> a

duplicate :: Arg e a -> Arg e (Arg e a)

extend :: (Arg e a -> b) -> Arg e a -> Arg e b

Comonad (Tagged s)

Defined in Control.Comonad

Methods

extract :: Tagged s a -> a

duplicate :: Tagged s a -> Tagged s (Tagged s a)

extend :: (Tagged s a -> b) -> Tagged s a -> Tagged s b

Comonad w => Comonad (IdentityT w)

Defined in Control.Comonad

Methods

extract :: IdentityT w a -> a

duplicate :: IdentityT w a -> IdentityT w (IdentityT w a)

extend :: (IdentityT w a -> b) -> IdentityT w a -> IdentityT w b

Comonad w => Comonad (EnvT e w)

Defined in Control.Comonad.Trans.Env

Methods

extract :: EnvT e w a -> a

duplicate :: EnvT e w a -> EnvT e w (EnvT e w a)

extend :: (EnvT e w a -> b) -> EnvT e w a -> EnvT e w b

Comonad w => Comonad (StoreT s w)

Defined in Control.Comonad.Trans.Store

Methods

extract :: StoreT s w a -> a

duplicate :: StoreT s w a -> StoreT s w (StoreT s w a)

extend :: (StoreT s w a -> b) -> StoreT s w a -> StoreT s w b

(Comonad w, Monoid m) => Comonad (TracedT m w)

Defined in Control.Comonad.Trans.Traced

Methods

extract :: TracedT m w a -> a

duplicate :: TracedT m w a -> TracedT m w (TracedT m w a)

extend :: (TracedT m w a -> b) -> TracedT m w a -> TracedT m w b

Monoid m => Comonad ((->) m :: Type -> Type)

Defined in Control.Comonad

Methods

extract :: (m -> a) -> a

duplicate :: (m -> a) -> m -> (m -> a)

extend :: ((m -> a) -> b) -> (m -> a) -> m -> b

(Comonad f, Comonad g) => Comonad (Sum f g)

Defined in Control.Comonad

Methods

extract :: Sum f g a -> a

duplicate :: Sum f g a -> Sum f g (Sum f g a)

extend :: (Sum f g a -> b) -> Sum f g a -> Sum f g b

liftW :: Comonad w => (a -> b) -> w a -> w b

A suitable default definition for fmap for a Comonad. Promotes a function to a comonad.

You can only safely use liftW to define fmap if your Comonad defines extend, not just duplicate, since defining extend in terms of duplicate uses fmap!

fmap f = liftW f = extend (f . extract)

wfix :: Comonad w => w (w a -> a) -> a

Comonadic fixed point à la David Menendez

cfix :: Comonad w => (w a -> a) -> w a

Comonadic fixed point à la Dominic Orchard

kfix :: ComonadApply w => w (w a -> a) -> w a

Comonadic fixed point à la Kenneth Foner:

This is the evaluate function from his "Getting a Quick Fix on Comonads" talk.

(=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c infixr 1

Left-to-right Cokleisli composition

(=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c infixr 1

Right-to-left Cokleisli composition

(<<=) :: Comonad w => (w a -> b) -> w a -> w b infixr 1

extend in operator form

(=>>) :: Comonad w => w a -> (w a -> b) -> w b infixl 1

extend with the arguments swapped. Dual to >>= for a Monad.

Combining Comonads

class Comonad w => ComonadApply w where

ComonadApply is to Comonad like Applicative is to Monad.

Mathematically, it is a strong lax symmetric semi-monoidal comonad on the category Hask of Haskell types. That it to say that w is a strong lax symmetric semi-monoidal functor on Hask, where both extract and duplicate are symmetric monoidal natural transformations.

Laws:

(.) <$> u <@> v <@> w = u <@> (v <@> w)
extract (p <@> q) = extract p (extract q)
duplicate (p <@> q) = (<@>) <$> duplicate p <@> duplicate q

If our type is both a ComonadApply and Applicative we further require

(<*>) = (<@>)

Finally, if you choose to define (<@) and (@>), the results of your definitions should match the following laws:

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

Minimal complete definition

Nothing

Methods

(<@>) :: w (a -> b) -> w a -> w b infixl 4

default (<@>) :: Applicative w => w (a -> b) -> w a -> w b

(@>) :: w a -> w b -> w b infixl 4

(<@) :: w a -> w b -> w a infixl 4

Instances

ComonadApply Identity

Defined in Control.Comonad

Methods

(<@>) :: Identity (a -> b) -> Identity a -> Identity b

(@>) :: Identity a -> Identity b -> Identity b

(<@) :: Identity a -> Identity b -> Identity a

ComonadApply NonEmpty

Defined in Control.Comonad

Methods

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

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

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

ComonadApply Tree

Defined in Control.Comonad

Methods

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

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

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

Semigroup m => ComonadApply ((,) m)

Defined in Control.Comonad

Methods

(<@>) :: (m, a -> b) -> (m, a) -> (m, b)

(@>) :: (m, a) -> (m, b) -> (m, b)

(<@) :: (m, a) -> (m, b) -> (m, a)

ComonadApply w => ComonadApply (IdentityT w)

Defined in Control.Comonad

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

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

Defined in Control.Comonad.Trans.Env

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

(ComonadApply w, Semigroup s) => ComonadApply (StoreT s w)

Defined in Control.Comonad.Trans.Store

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

(ComonadApply w, Monoid m) => ComonadApply (TracedT m w)

Defined in Control.Comonad.Trans.Traced

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

Monoid m => ComonadApply ((->) m :: Type -> Type)

Defined in Control.Comonad

Methods

(<@>) :: (m -> (a -> b)) -> (m -> a) -> m -> b

(@>) :: (m -> a) -> (m -> b) -> m -> b

(<@) :: (m -> a) -> (m -> b) -> m -> a

(<@@>) :: ComonadApply w => w a -> w (a -> b) -> w b infixl 4

A variant of <@> with the arguments reversed.

liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c

Lift a binary function into a Comonad with zipping

liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d

Lift a ternary function into a Comonad with zipping

Cokleisli Arrows

newtype Cokleisli w a b

The Cokleisli Arrows of a given Comonad

Constructors

Cokleisli

Fields

• runCokleisli :: w a -> b

Instances

Comonad w => Category (Cokleisli w :: Type -> Type -> Type)

Defined in Control.Comonad

Methods

id :: forall (a :: k). Cokleisli w a a

(.) :: forall (b :: k) (c :: k) (a :: k). Cokleisli w b c -> Cokleisli w a b -> Cokleisli w a c

Comonad w => Arrow (Cokleisli w)

Defined in Control.Comonad

Methods

arr :: (b -> c) -> Cokleisli w b c

first :: Cokleisli w b c -> Cokleisli w (b, d) (c, d)

second :: Cokleisli w b c -> Cokleisli w (d, b) (d, c)

(***) :: Cokleisli w b c -> Cokleisli w b' c' -> Cokleisli w (b, b') (c, c')

(&&&) :: Cokleisli w b c -> Cokleisli w b c' -> Cokleisli w b (c, c')

Comonad w => ArrowChoice (Cokleisli w)

Defined in Control.Comonad

Methods

left :: Cokleisli w b c -> Cokleisli w (Either b d) (Either c d)

right :: Cokleisli w b c -> Cokleisli w (Either d b) (Either d c)

(+++) :: Cokleisli w b c -> Cokleisli w b' c' -> Cokleisli w (Either b b') (Either c c')

(|||) :: Cokleisli w b d -> Cokleisli w c d -> Cokleisli w (Either b c) d

Comonad w => ArrowApply (Cokleisli w)

Defined in Control.Comonad

Methods

app :: Cokleisli w (Cokleisli w b c, b) c

ComonadApply w => ArrowLoop (Cokleisli w)

Defined in Control.Comonad

Methods

loop :: Cokleisli w (b, d) (c, d) -> Cokleisli w b c

Monad (Cokleisli w a)

Defined in Control.Comonad

Methods

(>>=) :: Cokleisli w a a0 -> (a0 -> Cokleisli w a b) -> Cokleisli w a b

(>>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

return :: a0 -> Cokleisli w a a0

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

Applicative (Cokleisli w a)

Defined in Control.Comonad

Methods

pure :: a0 -> Cokleisli w a a0

(<*>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

liftA2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c

(*>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

(<*) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0

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

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor Complex

Since: base-4.9.0.0

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

Since: base-2.1

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 First

Since: base-4.8.0.0

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

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 P

Since: base-4.8.0.0

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

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

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

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

Since: base-4.9.0.0

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

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

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

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

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

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

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

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

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

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

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

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

Defined in Data.Semigroup.Internal

Methods

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

(<$) :: a -> Alt f b -> Alt f 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 f => Functor (Indexing f)

Defined in WithIndex

Methods

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

(<$) :: a -> Indexing f b -> Indexing f 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 :: Type -> Type)

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

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 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 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 (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 ((->) r :: Type -> Type)

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

Since: base-4.9.0.0

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

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

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

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

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 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 (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 (M1 i c f)

Since: base-4.9.0.0

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

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

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

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

do as
   pure b

with an inferred Functor constraint.

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