profunctors-5.1.1: Profunctors

Copyright(C) 2011-2013 Edward Kmett,
LicenseBSD-style (see the file LICENSE)
MaintainerEdward Kmett <>
Safe HaskellTrustworthy




For a good explanation of profunctors in Haskell see Dan Piponi's article:

For more information on strength and costrength, see:



class Profunctor p where Source

Formally, the class Profunctor represents a profunctor from Hask -> Hask.

Intuitively it is a bifunctor where the first argument is contravariant and the second argument is covariant.

You can define a Profunctor by either defining dimap or by defining both lmap and rmap.

If you supply dimap, you should ensure that:

dimap id idid

If you supply lmap and rmap, ensure:

lmap idid
rmap idid

If you supply both, you should also ensure:

dimap f g ≡ lmap f . rmap g

These ensure by parametricity:

dimap (f . g) (h . i) ≡ dimap g h . dimap f i
lmap (f . g) ≡ lmap g . lmap f
rmap (f . g) ≡ rmap f . rmap g

Minimal complete definition

dimap | lmap, rmap


dimap :: (a -> b) -> (c -> d) -> p b c -> p a d Source

Map over both arguments at the same time.

dimap f g ≡ lmap f . rmap g

lmap :: (a -> b) -> p b c -> p a c Source

Map the first argument contravariantly.

lmap f ≡ dimap f id

rmap :: (b -> c) -> p a b -> p a c Source

Map the second argument covariantly.

rmapdimap id

Profunctorial Strength

class Profunctor p => Strong p where Source

Generalizing Star of a strong Functor

Note: Every Functor in Haskell is strong with respect to (,).

This describes profunctor strength with respect to the product structure of Hask.

Minimal complete definition

first' | second'


first' :: p a b -> p (a, c) (b, c) Source

second' :: p a b -> p (c, a) (c, b) Source


class Profunctor p => Choice p where Source

The generalization of Costar of Functor that is strong with respect to Either.

Note: This is also a notion of strength, except with regards to another monoidal structure that we can choose to equip Hask with: the cocartesian coproduct.

Minimal complete definition

left' | right'


left' :: p a b -> p (Either a c) (Either b c) Source

right' :: p a b -> p (Either c a) (Either c b) Source


Choice (->) 
Monad m => Choice (Kleisli m) 
Comonad w => Choice (Cokleisli w)

extract approximates costrength

Choice (Tagged *) 
Monoid r => Choice (Forget r) 
ArrowChoice p => Choice (WrappedArrow p) 
Traversable w => Choice (Costar w) 
Applicative f => Choice (Star f) 
Profunctor p => Choice (Cotambara p) 
Choice p => Choice (Tambara p) 
(Functor f, Choice p) => Choice (Cayley f p) 
(Choice p, Choice q) => Choice (Procompose p q) 

Profunctorial Costrength

class Profunctor p => Costrong p where Source

Analogous to ArrowLoop, loop = unfirst

Minimal complete definition

unfirst | unsecond


unfirst :: p (a, d) (b, d) -> p a b Source

unsecond :: p (d, a) (d, b) -> p a b Source

class Profunctor p => Cochoice p where Source

Minimal complete definition

unleft | unright


unleft :: p (Either a d) (Either b d) -> p a b Source

unright :: p (Either d a) (Either d b) -> p a b Source


Common Profunctors

newtype Star f d c Source

Lift a Functor into a Profunctor (forwards).




runStar :: d -> f c


Functor f => Profunctor (Star f) 
Traversable f => Cochoice (Star f) 
Applicative f => Choice (Star f) 
Functor m => Strong (Star m) 
Distributive f => Closed (Star f) 
Functor f => Representable (Star f) 
Functor f => Sieve (Star f) f 
Alternative f => Alternative (Star f a) 
Monad f => Monad (Star f a) 
Functor f => Functor (Star f a) 
MonadPlus f => MonadPlus (Star f a) 
Applicative f => Applicative (Star f a) 
Distributive f => Distributive (Star f a) 
type Rep (Star f) = f 

newtype Costar f d c Source

Lift a Functor into a Profunctor (backwards).




runCostar :: f d -> c


newtype Forget r a b Source




runForget :: a -> r


type (:->) p q = forall a b. p a b -> q a b infixr 0 Source