Copyright  (C) 20142015 Edward Kmett 

License  BSDstyle (see the file LICENSE) 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  experimental 
Portability  portable 
Safe Haskell  Safe 
Language  Haskell2010 
 class Profunctor p => Closed p where
 newtype Closure p a b = Closure {
 runClosure :: forall x. p (x > a) (x > b)
 close :: Closed p => (p :> q) > p :> Closure q
 unclose :: Profunctor q => (p :> Closure q) > p :> q
 data Environment p a b where
 Environment :: ((z > y) > b) > p x y > (a > z > x) > Environment p a b
 curry' :: Closed p => p (a, b) c > p a (b > c)
Documentation
class Profunctor p => Closed p where #
A strong profunctor allows the monoidal structure to pass through.
A closed profunctor allows the closed structure to pass through.
Closed (>) #  
(Distributive f, Monad f) => Closed (Kleisli f) #  
Functor f => Closed (Cokleisli f) #  
Closed (Tagged *) #  
Functor f => Closed (Costar f) #  
Distributive f => Closed (Star f) #  
Closed (Environment p) #  
Profunctor p => Closed (Closure p) #  
Closed (FreeMapping p) #  
Profunctor p => Closed (CofreeMapping p) #  
Closed p => Closed (Coyoneda p) #  
Closed p => Closed (Yoneda p) #  
(Closed p, Closed q) => Closed (Procompose p q) #  
(Closed p, Closed q) => Closed (Product * * p q) #  
(Functor f, Closed p) => Closed (Tannen * * * f p) #  
Closure
adjoins a Closed
structure to any Profunctor
.
Closure  

ProfunctorComonad Closure #  
ProfunctorFunctor Closure #  
ProfunctorAdjunction Environment Closure #  
Arrow p => Arrow (Closure p) #  
ArrowZero p => ArrowZero (Closure p) #  
ArrowPlus p => ArrowPlus (Closure p) #  
ArrowLoop p => ArrowLoop (Closure p) #  
Profunctor p => Profunctor (Closure p) #  
Strong p => Strong (Closure p) #  
Profunctor p => Closed (Closure p) #  
Category * p => Category * (Closure p) #  
Profunctor p => Functor (Closure p a) #  
(Profunctor p, Arrow p) => Applicative (Closure p a) #  
(Profunctor p, ArrowPlus p) => Alternative (Closure p a) #  
(Profunctor p, Arrow p, Monoid b) => Monoid (Closure p a b) #  
data Environment p a b where #
Environment :: ((z > y) > b) > p x y > (a > z > x) > Environment p a b 