| 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/
- class Profunctor p where
- newtype Star f d c = Star {
- runStar :: d -> f c
- newtype Costar f d c = Costar {
- runCostar :: f d -> c
- newtype WrappedArrow p a b = WrapArrow {
- unwrapArrow :: p a b
- newtype Forget r a b = Forget {
- runForget :: a -> r
- type (:->) p q = forall a b. p a b -> q a b
Documentation
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:
dimapidid≡id
If you supply lmap and rmap, ensure:
lmapid≡idrmapid≡id
If you supply both, you should also ensure:
dimapf g ≡lmapf.rmapg
These ensure by parametricity:
dimap(f.g) (h.i) ≡dimapg h.dimapf ilmap(f.g) ≡lmapg.lmapfrmap(f.g) ≡rmapf.rmapg
Methods
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
Instances
newtype Star f d c
Lift a Functor into a Profunctor (forwards).
Instances
| Functor f => Profunctor (Star f) | |
| Functor m => Strong (Star m) | |
| Distributive f => Closed (Star f) | |
| Traversable f => Cochoice (Star f) | |
| Applicative f => Choice (Star f) | |
| Applicative m => Traversing (Star m) | |
| (Applicative m, Distributive m) => Mapping (Star m) | |
| Functor f => Representable (Star f) | |
| Functor f => Sieve (Star f) f | |
| Monad f => Monad (Star f a) | |
| Functor f => Functor (Star f a) | |
| Applicative f => Applicative (Star f a) | |
| Alternative f => Alternative (Star f a) | |
| MonadPlus f => MonadPlus (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).
Instances
| Functor f => Profunctor (Costar f) | |
| Functor f => Costrong (Costar f) | |
| Functor f => Closed (Costar f) | |
| Applicative f => Cochoice (Costar f) | |
| Traversable w => Choice (Costar w) | |
| 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
| |
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) | |
| Arrow p => Strong (WrappedArrow p) | |
| ArrowChoice p => Choice (WrappedArrow p) |
newtype Forget r a b
type (:->) p q = forall a b. p a b -> q a b infixr 0