profunctors-5.6.2: Profunctors

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

Data.Profunctor.Composition

Contents

- Profunctor Composition
- Unitors and Associator
- Categories as monoid objects
- Generalized Composition
- Right Kan Lift

Description

Synopsis

- data Procompose p q d c where
  - Procompose :: p x c -> q d x -> Procompose p q d c
- procomposed :: Category p => Procompose p p a b -> p a b
- idl :: Profunctor q => Iso (Procompose (->) q d c) (Procompose (->) r d' c') (q d c) (r d' c')
- idr :: Profunctor q => Iso (Procompose q (->) d c) (Procompose r (->) d' c') (q d c) (r d' c')
- assoc :: Iso (Procompose p (Procompose q r) a b) (Procompose x (Procompose y z) a b) (Procompose (Procompose p q) r a b) (Procompose (Procompose x y) z a b)
- eta :: (Profunctor p, Category p) => (->) :-> p
- mu :: Category p => Procompose p p :-> p
- stars :: Functor g => Iso (Procompose (Star f) (Star g) d c) (Procompose (Star f') (Star g') d' c') (Star (Compose g f) d c) (Star (Compose g' f') d' c')
- kleislis :: Monad g => Iso (Procompose (Kleisli f) (Kleisli g) d c) (Procompose (Kleisli f') (Kleisli g') d' c') (Kleisli (Compose g f) d c) (Kleisli (Compose g' f') d' c')
- costars :: Functor f => Iso (Procompose (Costar f) (Costar g) d c) (Procompose (Costar f') (Costar g') d' c') (Costar (Compose f g) d c) (Costar (Compose f' g') d' c')
- cokleislis :: Functor f => Iso (Procompose (Cokleisli f) (Cokleisli g) d c) (Procompose (Cokleisli f') (Cokleisli g') d' c') (Cokleisli (Compose f g) d c) (Cokleisli (Compose f' g') d' c')
- newtype Rift p q a b = Rift {
  - runRift :: forall x. p b x -> q a x
  }
- decomposeRift :: Procompose p (Rift p q) :-> q

# Profunctor Composition

data Procompose p q d c where #

``Procompose` p q` is the `Profunctor` composition of the `Profunctor`s `p` and `q`.

For a good explanation of `Profunctor` composition in Haskell see Dan Piponi's article:

http://blog.sigfpe.com/2011/07/profunctors-in-haskell.html

`Procompose` has a polymorphic kind since `5.6`.

Constructors

Procompose :: p x c -> q d x -> Procompose p q d c |

#### Instances

Instances details

ProfunctorFunctor (Procompose p :: (Type -> Type -> Type) -> Type -> k1 -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods promap :: forall (p0 :: Type -> Type -> Type) (q :: Type -> Type -> Type). Profunctor p0 => (p0 :-> q) -> Procompose p p0 :-> Procompose p q #
Category p => ProfunctorMonad (Procompose p :: (Type -> Type -> Type) -> Type -> Type -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods proreturn :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => p0 :-> Procompose p p0 # projoin :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => Procompose p (Procompose p p0) :-> Procompose p p0 #
ProfunctorAdjunction (Procompose p :: (Type -> Type -> Type) -> Type -> Type -> Type) (Rift p :: (Type -> Type -> Type) -> Type -> Type -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods unit :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => p0 :-> Rift p (Procompose p p0) # counit :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => Procompose p (Rift p p0) :-> p0 #
(Choice p, Choice q) => Choice (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods left' :: Procompose p q a b -> Procompose p q (Either a c) (Either b c) # right' :: Procompose p q a b -> Procompose p q (Either c a) (Either c b) #
(Closed p, Closed q) => Closed (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods closed :: Procompose p q a b -> Procompose p q (x -> a) (x -> b) #
(Mapping p, Mapping q) => Mapping (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods map' :: Functor f => Procompose p q a b -> Procompose p q (f a) (f b) # roam :: ((a -> b) -> s -> t) -> Procompose p q a b -> Procompose p q s t #
(Corepresentable p, Corepresentable q) => Corepresentable (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Associated Types type Corep (Procompose p q) :: Type -> Type # Methods cotabulate :: (Corep (Procompose p q) d -> c) -> Procompose p q d c #
(Representable p, Representable q) => Representable (Procompose p q) # | The composition of two `Representable` `Profunctor`s is `Representable` by the composition of their representations.
Instance details Defined in Data.Profunctor.Composition Associated Types type Rep (Procompose p q) :: Type -> Type # Methods tabulate :: (d -> Rep (Procompose p q) c) -> Procompose p q d c #
(Corepresentable p, Corepresentable q) => Costrong (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods unfirst :: Procompose p q (a, d) (b, d) -> Procompose p q a b # unsecond :: Procompose p q (d, a) (d, b) -> Procompose p q a b #
(Strong p, Strong q) => Strong (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods first' :: Procompose p q a b -> Procompose p q (a, c) (b, c) # second' :: Procompose p q a b -> Procompose p q (c, a) (c, b) #
(Traversing p, Traversing q) => Traversing (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods traverse' :: Traversable f => Procompose p q a b -> Procompose p q (f a) (f b) # wander :: (forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t) -> Procompose p q a b -> Procompose p q s t #
(Profunctor p, Profunctor q) => Profunctor (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Procompose p q b c -> Procompose p q a d # lmap :: (a -> b) -> Procompose p q b c -> Procompose p q a c # rmap :: (b -> c) -> Procompose p q a b -> Procompose p q a c # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Procompose p q a b -> Procompose p q a c # (.#) :: forall a b c q0. Coercible b a => Procompose p q b c -> q0 a b -> Procompose p q a c #
(Cosieve p f, Cosieve q g) => Cosieve (Procompose p q) (Compose f g) # |
Instance details Defined in Data.Profunctor.Composition Methods cosieve :: Procompose p q a b -> Compose f g a -> b #
(Sieve p f, Sieve q g) => Sieve (Procompose p q) (Compose g f) # |
Instance details Defined in Data.Profunctor.Composition Methods sieve :: Procompose p q a b -> a -> Compose g f b #
Profunctor p => Functor (Procompose p q a) # |
Instance details Defined in Data.Profunctor.Composition Methods fmap :: (a0 -> b) -> Procompose p q a a0 -> Procompose p q a b # (<$) :: a0 -> Procompose p q a b -> Procompose p q a a0 #
type Corep (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition type Corep (Procompose p q) = Compose (Corep p) (Corep q)
type Rep (Procompose p q) # |
Instance details Defined in Data.Profunctor.Composition type Rep (Procompose p q) = Compose (Rep q) (Rep p)

procomposed :: Category p => Procompose p p a b -> p a b #

# Unitors and Associator

idl :: Profunctor q => Iso (Procompose (->) q d c) (Procompose (->) r d' c') (q d c) (r d' c') #

`(->)` functions as a lax identity for `Profunctor` composition.

This provides an `Iso` for the `lens` package that witnesses the isomorphism between ``Procompose` (->) q d c` and `q d c`, which is the left identity law.

    idl :: Profunctor q => Iso' (Procompose (->) q d c) (q d c)

idr :: Profunctor q => Iso (Procompose q (->) d c) (Procompose r (->) d' c') (q d c) (r d' c') #

`(->)` functions as a lax identity for `Profunctor` composition.

This provides an `Iso` for the `lens` package that witnesses the isomorphism between ``Procompose` q (->) d c` and `q d c`, which is the right identity law.

    idr :: Profunctor q => Iso' (Procompose q (->) d c) (q d c)

assoc :: Iso (Procompose p (Procompose q r) a b) (Procompose x (Procompose y z) a b) (Procompose (Procompose p q) r a b) (Procompose (Procompose x y) z a b) #

The associator for `Profunctor` composition.

This provides an `Iso` for the `lens` package that witnesses the isomorphism between ``Procompose` p (`Procompose` q r) a b` and ``Procompose` (`Procompose` p q) r a b`, which arises because `Prof` is only a bicategory, rather than a strict 2-category.

# Categories as monoid objects

eta :: (Profunctor p, Category p) => (->) :-> p #

a `Category` that is also a `Profunctor` is a `Monoid` in `Prof`

mu :: Category p => Procompose p p :-> p #

# Generalized Composition

stars :: Functor g => Iso (Procompose (Star f) (Star g) d c) (Procompose (Star f') (Star g') d' c') (Star (Compose g f) d c) (Star (Compose g' f') d' c') #

`Profunctor` composition generalizes `Functor` composition in two ways.

This is the first, which shows that `exists b. (a -> f b, b -> g c)` is isomorphic to `a -> f (g c)`.

    stars :: Functor f => Iso' (Procompose (Star f) (Star g) d c) (Star (Compose f g) d c)

kleislis :: Monad g => Iso (Procompose (Kleisli f) (Kleisli g) d c) (Procompose (Kleisli f') (Kleisli g') d' c') (Kleisli (Compose g f) d c) (Kleisli (Compose g' f') d' c') #

This is a variant on `stars` that uses `Kleisli` instead of `Star`.

    kleislis :: Monad f => Iso' (Procompose (Kleisli f) (Kleisli g) d c) (Kleisli (Compose f g) d c)

costars :: Functor f => Iso (Procompose (Costar f) (Costar g) d c) (Procompose (Costar f') (Costar g') d' c') (Costar (Compose f g) d c) (Costar (Compose f' g') d' c') #

`Profunctor` composition generalizes `Functor` composition in two ways.

This is the second, which shows that `exists b. (f a -> b, g b -> c)` is isomorphic to `g (f a) -> c`.

    costars :: Functor f => Iso' (Procompose (Costar f) (Costar g) d c) (Costar (Compose g f) d c)

cokleislis :: Functor f => Iso (Procompose (Cokleisli f) (Cokleisli g) d c) (Procompose (Cokleisli f') (Cokleisli g') d' c') (Cokleisli (Compose f g) d c) (Cokleisli (Compose f' g') d' c') #

This is a variant on `costars` that uses `Cokleisli` instead of `Costar`.

    cokleislis :: Functor f => Iso' (Procompose (Cokleisli f) (Cokleisli g) d c) (Cokleisli (Compose g f) d c)

# Right Kan Lift

newtype Rift p q a b #

This represents the right Kan lift of a `Profunctor` `q` along a `Profunctor` `p` in a limited version of the 2-category of Profunctors where the only object is the category Hask, 1-morphisms are profunctors composed and compose with Profunctor composition, and 2-morphisms are just natural transformations.

`Rift` has a polymorphic kind since `5.6`.

Constructors

Rift |
Fields runRift :: forall x. p b x -> q a x

#### Instances

Instances details

ProfunctorFunctor (Rift p :: (Type -> Type -> Type) -> Type -> k1 -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods promap :: forall (p0 :: Type -> Type -> Type) (q :: Type -> Type -> Type). Profunctor p0 => (p0 :-> q) -> Rift p p0 :-> Rift p q #
p ~ q => Category (Rift p q :: k1 -> k1 -> Type) # | ``Rift` p p` forms a `Monad` in the `Profunctor` 2-category, which is isomorphic to a Haskell `Category` instance.
Instance details Defined in Data.Profunctor.Composition Methods id :: forall (a :: k). Rift p q a a (.) :: forall (b :: k) (c :: k) (a :: k). Rift p q b c -> Rift p q a b -> Rift p q a c
Category p => ProfunctorComonad (Rift p :: (Type -> Type -> Type) -> Type -> Type -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods proextract :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => Rift p p0 :-> p0 # produplicate :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => Rift p p0 :-> Rift p (Rift p p0) #
ProfunctorAdjunction (Procompose p :: (Type -> Type -> Type) -> Type -> Type -> Type) (Rift p :: (Type -> Type -> Type) -> Type -> Type -> Type) # |
Instance details Defined in Data.Profunctor.Composition Methods unit :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => p0 :-> Rift p (Procompose p p0) # counit :: forall (p0 :: Type -> Type -> Type). Profunctor p0 => Procompose p (Rift p p0) :-> p0 #
(Profunctor p, Profunctor q) => Profunctor (Rift p q) # |
Instance details Defined in Data.Profunctor.Composition Methods dimap :: (a -> b) -> (c -> d) -> Rift p q b c -> Rift p q a d # lmap :: (a -> b) -> Rift p q b c -> Rift p q a c # rmap :: (b -> c) -> Rift p q a b -> Rift p q a c # (#.) :: forall a b c q0. Coercible c b => q0 b c -> Rift p q a b -> Rift p q a c # (.#) :: forall a b c q0. Coercible b a => Rift p q b c -> q0 a b -> Rift p q a c #
Profunctor p => Functor (Rift p q a) # |
Instance details Defined in Data.Profunctor.Composition Methods fmap :: (a0 -> b) -> Rift p q a a0 -> Rift p q a b # (<$) :: a0 -> Rift p q a b -> Rift p q a a0 #

decomposeRift :: Procompose p (Rift p q) :-> q #

The 2-morphism that defines a left Kan lift.

Note: When `p` is right adjoint to ``Rift` p (->)` then `decomposeRift` is the `counit` of the adjunction.