profunctors-4.0.1: Profunctors

Portability | portable
Stability | provisional
Maintainer | Edward Kmett <ekmett@gmail.com>
Safe Haskell | Trustworthy

Data.Profunctor

Contents

- Profunctors
  - Profunctorial Strength
  - Common Profunctors

Description

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/

Synopsis

- class Profunctor p where
  - dimap :: (a -> b) -> (c -> d) -> p b c -> p a d
  - lmap :: (a -> b) -> p b c -> p a c
  - rmap :: (b -> c) -> p a b -> p a c
- class Profunctor p => Strong p where
  - first' :: p a b -> p (a, c) (b, c)
  - second' :: p a b -> p (c, a) (c, b)
- class Profunctor p => Choice p where
  - left' :: p a b -> p (Either a c) (Either b c)
  - right' :: p a b -> p (Either c a) (Either c b)
- newtype UpStar f d c = UpStar {
  - runUpStar :: d -> f c
  }
- newtype DownStar f d c = DownStar {
  - runDownStar :: f d -> c
  }
- newtype WrappedArrow p a b = WrapArrow {
  - unwrapArrow :: p a b
  }
- newtype Forget r a b = Forget {
  - runForget :: a -> r
  }

# Profunctors

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

Methods

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

Map over both arguments at the same time.

    dimap f g ≡ lmap f . rmap g

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

Map the first argument contravariantly.

    lmap f ≡ dimap f id

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

Map the second argument covariantly.

    rmap ≡ dimap id

Instances

Profunctor (->) |
Monad m => Profunctor (Kleisli m) |
Functor w => Profunctor (Cokleisli w) |
Profunctor (Tagged *) |
Profunctor (Forget r) |
Arrow p => Profunctor (WrappedArrow p) |
Functor f => Profunctor (DownStar f) |
Functor f => Profunctor (UpStar f) |
(Profunctor p, Profunctor q) => Profunctor (Procompose p q) |
(Profunctor p, Profunctor q) => Profunctor (Rift p q) |

## Profunctorial Strength

class Profunctor p => Strong p where Source

Generalizing upstar of a strong `Functor`

Minimal complete definition: `first'` or `second'`

Note: Every `Functor` in Haskell is strong.

Methods

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

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

Instances

Strong (->) |
Monad m => Strong (Kleisli m) |
Strong (Forget r) |
Arrow p => Strong (WrappedArrow p) |
Functor m => Strong (UpStar m) |
(Strong p, Strong q) => Strong (Procompose p q) |

class Profunctor p => Choice p where Source

The generalization of `DownStar` of a "costrong" `Functor`

Minimal complete definition: `left'` or `right'`

Note: We use `traverse` and `extract` as approximate costrength as needed.

Methods

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

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

Instances

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 (DownStar w) | `sequence` approximates `costrength`
Applicative f => Choice (UpStar f) |
(Choice p, Choice q) => Choice (Procompose p q) |

## Common Profunctors

newtype UpStar f d c Source

Lift a `Functor` into a `Profunctor` (forwards).

Constructors

UpStar |

Fields

runUpStar :: d -> f c

Instances

Functor f => Profunctor (UpStar f) |
Applicative f => Choice (UpStar f) |
Functor m => Strong (UpStar m) |
Functor f => Representable (UpStar f) |
Functor f => Functor (UpStar f a) |

newtype DownStar f d c Source

Lift a `Functor` into a `Profunctor` (backwards).

Constructors

DownStar |

Fields

runDownStar :: f d -> c

Instances

Functor f => Profunctor (DownStar f) |
Traversable w => Choice (DownStar w) | `sequence` approximates `costrength`
Functor f => Corepresentable (DownStar f) |
Functor (DownStar f a) |

newtype WrappedArrow p a b Source

Wrap an arrow for use as a `Profunctor`.

Constructors

WrapArrow |

Fields

unwrapArrow :: p a b

Instances

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) |
Category p => Category (WrappedArrow p) |
Arrow p => Profunctor (WrappedArrow p) |
ArrowChoice p => Choice (WrappedArrow p) |
Arrow p => Strong (WrappedArrow p) |

newtype Forget r a b Source

Constructors

Forget |

Fields

runForget :: a -> r

Instances

Profunctor (Forget r) |
Monoid r => Choice (Forget r) |
Strong (Forget r) |
Functor (Forget r a) |
Foldable (Forget r a) |
Traversable (Forget r a) |