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

Data.Profunctor.Monad

Description

Synopsis

Documentation

class ProfunctorFunctor t where #

Minimal complete definition

promap

Methods

promap :: Profunctor p => (p :-> q) -> t p :-> t q #

Laws:

promap f . promap g ≡ promap (f . g)
promap id ≡ id

Instances

ProfunctorFunctor Copastro #
Methods promap :: Profunctor p => (p :-> q) -> Copastro p :-> Copastro q #
ProfunctorFunctor Cotambara #
Methods promap :: Profunctor p => (p :-> q) -> Cotambara p :-> Cotambara q #
ProfunctorFunctor Pastro #
Methods promap :: Profunctor p => (p :-> q) -> Pastro p :-> Pastro q #
ProfunctorFunctor Tambara #
Methods promap :: Profunctor p => (p :-> q) -> Tambara p :-> Tambara q #
ProfunctorFunctor CopastroSum #
Methods promap :: Profunctor p => (p :-> q) -> CopastroSum p :-> CopastroSum q #
ProfunctorFunctor CotambaraSum #
Methods promap :: Profunctor p => (p :-> q) -> CotambaraSum p :-> CotambaraSum q #
ProfunctorFunctor PastroSum #
Methods promap :: Profunctor p => (p :-> q) -> PastroSum p :-> PastroSum q #
ProfunctorFunctor TambaraSum #
Methods promap :: Profunctor p => (p :-> q) -> TambaraSum p :-> TambaraSum q #
ProfunctorFunctor Environment #
Methods promap :: Profunctor p => (p :-> q) -> Environment p :-> Environment q #
ProfunctorFunctor Closure #
Methods promap :: Profunctor p => (p :-> q) -> Closure p :-> Closure q #
ProfunctorFunctor FreeTraversing #
Methods promap :: Profunctor p => (p :-> q) -> FreeTraversing p :-> FreeTraversing q #
ProfunctorFunctor CofreeTraversing #
Methods promap :: Profunctor p => (p :-> q) -> CofreeTraversing p :-> CofreeTraversing q #
ProfunctorFunctor FreeMapping #
Methods promap :: Profunctor p => (p :-> q) -> FreeMapping p :-> FreeMapping q #
ProfunctorFunctor CofreeMapping #
Methods promap :: Profunctor p => (p :-> q) -> CofreeMapping p :-> CofreeMapping q #
ProfunctorFunctor Coyoneda #
Methods promap :: Profunctor p => (p :-> q) -> Coyoneda p :-> Coyoneda q #
ProfunctorFunctor Yoneda #
Methods promap :: Profunctor p => (p :-> q) -> Yoneda p :-> Yoneda q #
Functor f => ProfunctorFunctor (Cayley f) #
Methods promap :: Profunctor p => (p :-> q) -> Cayley f p :-> Cayley f q #
ProfunctorFunctor (Rift p) #
Methods promap :: Profunctor p => (p :-> q) -> Rift p p :-> Rift p q #
ProfunctorFunctor (Procompose p) #
Methods promap :: Profunctor p => (p :-> q) -> Procompose p p :-> Procompose p q #
ProfunctorFunctor (Ran p) #
Methods promap :: Profunctor p => (p :-> q) -> Ran p p :-> Ran p q #
ProfunctorFunctor (Product * * p) #
Methods promap :: Profunctor p => (p :-> q) -> Product * * p p :-> Product * * p q #
ProfunctorFunctor (Sum * * p) #
Methods promap :: Profunctor p => (p :-> q) -> Sum * * p p :-> Sum * * p q #
Functor f => ProfunctorFunctor (Tannen * * * f) #
Methods promap :: Profunctor p => (p :-> q) -> Tannen * * * f p :-> Tannen * * * f q #

class ProfunctorFunctor t => ProfunctorMonad t where #

Laws:

promap f . proreturn ≡ proreturn . f
projoin . proreturn ≡ id
projoin . promap proreturn ≡ id
projoin . projoin ≡ projoin . promap projoin

Minimal complete definition

proreturn, projoin

Methods

proreturn :: Profunctor p => p :-> t p #

projoin :: Profunctor p => t (t p) :-> t p #

Instances

ProfunctorMonad Copastro #
Methods proreturn :: Profunctor p => p :-> Copastro p # projoin :: Profunctor p => Copastro (Copastro p) :-> Copastro p #
ProfunctorMonad Pastro #
Methods proreturn :: Profunctor p => p :-> Pastro p # projoin :: Profunctor p => Pastro (Pastro p) :-> Pastro p #
ProfunctorMonad CopastroSum #
Methods proreturn :: Profunctor p => p :-> CopastroSum p # projoin :: Profunctor p => CopastroSum (CopastroSum p) :-> CopastroSum p #
ProfunctorMonad PastroSum #
Methods proreturn :: Profunctor p => p :-> PastroSum p # projoin :: Profunctor p => PastroSum (PastroSum p) :-> PastroSum p #
ProfunctorMonad Environment #
Methods proreturn :: Profunctor p => p :-> Environment p # projoin :: Profunctor p => Environment (Environment p) :-> Environment p #
ProfunctorMonad FreeTraversing #
Methods proreturn :: Profunctor p => p :-> FreeTraversing p # projoin :: Profunctor p => FreeTraversing (FreeTraversing p) :-> FreeTraversing p #
ProfunctorMonad FreeMapping #
Methods proreturn :: Profunctor p => p :-> FreeMapping p # projoin :: Profunctor p => FreeMapping (FreeMapping p) :-> FreeMapping p #
ProfunctorMonad Coyoneda #
Methods proreturn :: Profunctor p => p :-> Coyoneda p # projoin :: Profunctor p => Coyoneda (Coyoneda p) :-> Coyoneda p #
ProfunctorMonad Yoneda #
Methods proreturn :: Profunctor p => p :-> Yoneda p # projoin :: Profunctor p => Yoneda (Yoneda p) :-> Yoneda p #
(Functor f, Monad f) => ProfunctorMonad (Cayley f) #	Cayley transforms Monads in `Hask` into monads on `Prof`
Methods proreturn :: Profunctor p => p :-> Cayley f p # projoin :: Profunctor p => Cayley f (Cayley f p) :-> Cayley f p #
Category * p => ProfunctorMonad (Procompose p) #
Methods proreturn :: Profunctor p => p :-> Procompose p p # projoin :: Profunctor p => Procompose p (Procompose p p) :-> Procompose p p #
ProfunctorMonad (Sum * * p) #
Methods proreturn :: Profunctor p => p :-> Sum * * p p # projoin :: Profunctor p => Sum * * p (Sum * * p p) :-> Sum * * p p #
Monad f => ProfunctorMonad (Tannen * * * f) #
Methods proreturn :: Profunctor p => p :-> Tannen * * * f p # projoin :: Profunctor p => Tannen * * * f (Tannen * * * f p) :-> Tannen * * * f p #

class ProfunctorFunctor t => ProfunctorComonad t where #

Laws:

proextract . promap f ≡ f . proextract
proextract . produplicate ≡ id
promap proextract . produplicate ≡ id
produplicate . produplicate ≡ promap produplicate . produplicate

Minimal complete definition

proextract, produplicate

Methods

proextract :: Profunctor p => t p :-> p #

produplicate :: Profunctor p => t p :-> t (t p) #

Instances

ProfunctorComonad Cotambara #
Methods proextract :: Profunctor p => Cotambara p :-> p # produplicate :: Profunctor p => Cotambara p :-> Cotambara (Cotambara p) #
ProfunctorComonad Tambara #
Methods proextract :: Profunctor p => Tambara p :-> p # produplicate :: Profunctor p => Tambara p :-> Tambara (Tambara p) #
ProfunctorComonad CotambaraSum #
Methods proextract :: Profunctor p => CotambaraSum p :-> p # produplicate :: Profunctor p => CotambaraSum p :-> CotambaraSum (CotambaraSum p) #
ProfunctorComonad TambaraSum #
Methods proextract :: Profunctor p => TambaraSum p :-> p # produplicate :: Profunctor p => TambaraSum p :-> TambaraSum (TambaraSum p) #
ProfunctorComonad Closure #
Methods proextract :: Profunctor p => Closure p :-> p # produplicate :: Profunctor p => Closure p :-> Closure (Closure p) #
ProfunctorComonad CofreeTraversing #
Methods proextract :: Profunctor p => CofreeTraversing p :-> p # produplicate :: Profunctor p => CofreeTraversing p :-> CofreeTraversing (CofreeTraversing p) #
ProfunctorComonad CofreeMapping #
Methods proextract :: Profunctor p => CofreeMapping p :-> p # produplicate :: Profunctor p => CofreeMapping p :-> CofreeMapping (CofreeMapping p) #
ProfunctorComonad Coyoneda #
Methods proextract :: Profunctor p => Coyoneda p :-> p # produplicate :: Profunctor p => Coyoneda p :-> Coyoneda (Coyoneda p) #
ProfunctorComonad Yoneda #
Methods proextract :: Profunctor p => Yoneda p :-> p # produplicate :: Profunctor p => Yoneda p :-> Yoneda (Yoneda p) #
Comonad f => ProfunctorComonad (Cayley f) #	Cayley transforms Comonads in `Hask` into comonads on `Prof`
Methods proextract :: Profunctor p => Cayley f p :-> p # produplicate :: Profunctor p => Cayley f p :-> Cayley f (Cayley f p) #
Category * p => ProfunctorComonad (Rift p) #
Methods proextract :: Profunctor p => Rift p p :-> p # produplicate :: Profunctor p => Rift p p :-> Rift p (Rift p p) #
Category * p => ProfunctorComonad (Ran p) #
Methods proextract :: Profunctor p => Ran p p :-> p # produplicate :: Profunctor p => Ran p p :-> Ran p (Ran p p) #
ProfunctorComonad (Product * * p) #
Methods proextract :: Profunctor p => Product * * p p :-> p # produplicate :: Profunctor p => Product * * p p :-> Product * * p (Product * * p p) #
Comonad f => ProfunctorComonad (Tannen * * * f) #
Methods proextract :: Profunctor p => Tannen * * * f p :-> p # produplicate :: Profunctor p => Tannen * * * f p :-> Tannen * * * f (Tannen * * * f p) #