Copyright	(C) 2011-2015 Edward Kmett,
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	provisional
Portability	portable
Safe Haskell	None
Language	Haskell2010

Data.Profunctor.Types

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

Documentation

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

Minimal complete definition

dimap | lmap, rmap

Methods

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.

rmap ≡ dimap id

Instances

Profunctor (->) Source
Monad m => Profunctor (Kleisli m) Source
Functor w => Profunctor (Cokleisli w) Source
Profunctor (Tagged *) Source
Profunctor (Forget r) Source
Arrow p => Profunctor (WrappedArrow p) Source
Functor f => Profunctor (Costar f) Source
Functor f => Profunctor (Star f) Source
Profunctor (Copastro p) Source
Profunctor (Cotambara p) Source
Profunctor (Pastro p) Source
Profunctor p => Profunctor (Tambara p) Source
Profunctor (Environment p) Source
Profunctor p => Profunctor (Closure p) Source
Profunctor (CopastroSum p) Source
Profunctor (CotambaraSum p) Source
Profunctor (PastroSum p) Source
Profunctor p => Profunctor (TambaraSum p) Source
Profunctor (FreeTraversing p) Source
Profunctor p => Profunctor (CofreeTraversing p) Source
Profunctor (FreeMapping p) Source
Profunctor p => Profunctor (CofreeMapping p) Source
Profunctor p => Profunctor (Codensity p) Source
(Functor f, Profunctor p) => Profunctor (Cayley f p) Source
(Profunctor p, Profunctor q) => Profunctor (Rift p q) Source
(Profunctor p, Profunctor q) => Profunctor (Procompose p q) Source
(Profunctor p, Profunctor q) => Profunctor (Ran p q) Source
Functor f => Profunctor (Joker * * f) Source
Contravariant f => Profunctor (Clown * * f) Source
(Profunctor p, Profunctor q) => Profunctor (Product * * p q) Source
(Functor f, Profunctor p) => Profunctor (Tannen * * * f p) Source
(Profunctor p, Functor f, Functor g) => Profunctor (Biff * * * * p f g) Source

newtype Star f d c Source

Lift a Functor into a Profunctor (forwards).

Constructors

Star
Fields runStar :: d -> f c

Instances

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

newtype Costar f d c Source

Lift a Functor into a Profunctor (backwards).

Constructors

Costar
Fields runCostar :: f d -> c

Instances

Functor f => Profunctor (Costar f) Source
Functor f => Costrong (Costar f) Source
Functor f => Closed (Costar f) Source
Applicative f => Cochoice (Costar f) Source
Traversable w => Choice (Costar w) Source
Functor f => Corepresentable (Costar f) Source
Functor f => Cosieve (Costar f) f Source
Monad (Costar f a) Source
Functor (Costar f a) Source
Applicative (Costar f a) Source
Distributive (Costar f d) Source
type Corep (Costar f) = f Source

newtype WrappedArrow p a b Source

Wrap an arrow for use as a Profunctor.

Constructors

WrapArrow
Fields unwrapArrow :: p a b

Instances

Category * p => Category * (WrappedArrow p) Source
Arrow p => Arrow (WrappedArrow p) Source
ArrowZero p => ArrowZero (WrappedArrow p) Source
ArrowChoice p => ArrowChoice (WrappedArrow p) Source
ArrowApply p => ArrowApply (WrappedArrow p) Source
ArrowLoop p => ArrowLoop (WrappedArrow p) Source
Arrow p => Profunctor (WrappedArrow p) Source
ArrowLoop p => Costrong (WrappedArrow p) Source
Arrow p => Strong (WrappedArrow p) Source	`Arrow` is `Strong` `Category`
ArrowChoice p => Choice (WrappedArrow p) Source

newtype Forget r a b Source

Constructors

Forget
Fields runForget :: a -> r

Instances

Profunctor (Forget r) Source
Strong (Forget r) Source
Monoid r => Choice (Forget r) Source
Representable (Forget r) Source
Sieve (Forget r) (Const r) Source
Functor (Forget r a) Source
Foldable (Forget r a) Source
Traversable (Forget r a) Source
type Rep (Forget r) = Const r Source

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