Data.Profunctor

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

http://blog.sigfpe.com/2011/07/profunctors-in-haskell.html

For more information on strength and costrength, see:

http://comonad.com/reader/2008/deriving-strength-from-laziness/

Profunctors

class Profunctor p where

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 id ≡ id

If you supply lmap and rmap, ensure:

lmap id ≡ id
rmap id ≡ id

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

Methods

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

Map over both arguments at the same time.

dimap f g ≡ lmap f . rmap g

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

Map the first argument contravariantly.

lmap f ≡ dimap f id

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

Map the second argument covariantly.

rmap ≡ dimap id

Instances

Profunctor (->)

Monad m => Profunctor (Kleisli m)

Profunctor (Tagged *)

Functor w => Profunctor (Cokleisli w)

Profunctor (Forget r)

Arrow p => Profunctor (WrappedArrow p)

Functor f => Profunctor (Costar f)

Functor f => Profunctor (Star f)

Profunctor p => Profunctor (Environment p)

Profunctor p => Profunctor (Closure p)

Profunctor p => Profunctor (Codensity p)

Profunctor p => Profunctor (Copastro p)

Profunctor p => Profunctor (Cotambara p)

Profunctor p => Profunctor (Pastro p)

Profunctor p => Profunctor (Tambara p)

(Functor f, Profunctor p) => Profunctor (Cayley f p)

(Profunctor p, Profunctor q) => Profunctor (Rift p q)

(Profunctor p, Profunctor q) => Profunctor (Procompose p q)

(Profunctor p, Profunctor q) => Profunctor (Ran p q)

Profunctorial Strength

class Profunctor p => Strong p where

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.

http://www-kb.is.s.u-tokyo.ac.jp/~asada/papers/arrStrMnd.pdf

Minimal complete definition

first' | second'

Methods

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

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

Instances

Strong (->)

Monad m => Strong (Kleisli m)

Strong (Forget r)

Arrow p => Strong (WrappedArrow p)

Arrow is Strong Category

Functor m => Strong (Star m)

Strong p => Strong (Closure p)

Profunctor p => Strong (Tambara p)

(Functor f, Strong p) => Strong (Cayley f p)

(Strong p, Strong q) => Strong (Procompose p q)

class Profunctor p => Choice p where

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'

Methods

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

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

Instances

Choice (->)

Monad m => Choice (Kleisli m)

Choice (Tagged *)

Comonad w => Choice (Cokleisli w)

extract approximates costrength

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

Analogous to ArrowLoop, loop = unfirst

Minimal complete definition

Nothing

Methods

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

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

Instances

Costrong (->)

MonadFix m => Costrong (Kleisli m)

Costrong (Tagged *)

ArrowLoop p => Costrong (WrappedArrow p)

class Profunctor p => Cochoice p where

Minimal complete definition

Nothing

Methods

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

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

Common Profunctors

newtype Star f d c

Lift a Functor into a Profunctor (forwards).

Constructors

Star

Fields

runStar :: d -> f c

Instances

Functor f => Profunctor (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

Lift a Functor into a Profunctor (backwards).

Constructors

Costar

Fields

runCostar :: f d -> c

Instances

Functor f => Profunctor (Costar f)

Traversable w => Choice (Costar w)

Functor f => Closed (Costar f)

Functor f => Corepresentable (Costar f)

Functor f => Cosieve (Costar f) f

Monad (Costar f a)

Functor (Costar f a)

Applicative (Costar f a)

Distributive (Costar f d)

type Corep (Costar f) = f

newtype WrappedArrow p a b

Wrap an arrow for use as a Profunctor.

Constructors

WrapArrow

Fields

unwrapArrow :: p a b

Instances

Category * p => Category * (WrappedArrow p)

Arrow p => Arrow (WrappedArrow p)

ArrowZero p => ArrowZero (WrappedArrow p)

ArrowChoice p => ArrowChoice (WrappedArrow p)

ArrowApply p => ArrowApply (WrappedArrow p)

ArrowLoop p => ArrowLoop (WrappedArrow p)

Arrow p => Profunctor (WrappedArrow p)

ArrowLoop p => Costrong (WrappedArrow p)

ArrowChoice p => Choice (WrappedArrow p)

Arrow p => Strong (WrappedArrow p)

Arrow is Strong Category

newtype Forget r a b

Constructors

Forget

Fields

runForget :: a -> r

Instances

Profunctor (Forget r)

Monoid r => Choice (Forget r)

Strong (Forget r)

Representable (Forget r)

Sieve (Forget r) (Const r)

Functor (Forget r a)

Foldable (Forget r a)

Traversable (Forget r a)

type Rep (Forget r) = Const r

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