profunctors-5.1.2: Profunctors

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

Data.Profunctor.Rep

Contents

- Representable Profunctors
- Corepresentable Profunctors
- Prep -| Star
- Coprep -| Costar

Description

Synopsis

- class (Sieve p (Rep p), Strong p) => Representable p where
  - type Rep p :: * -> *
  - tabulate :: (d -> Rep p c) -> p d c
- tabulated :: (Representable p, Representable q) => Iso (d -> Rep p c) (d' -> Rep q c') (p d c) (q d' c')
- firstRep :: Representable p => p a b -> p (a, c) (b, c)
- secondRep :: Representable p => p a b -> p (c, a) (c, b)
- class (Cosieve p (Corep p), Costrong p) => Corepresentable p where
  - type Corep p :: * -> *
  - cotabulate :: (Corep p d -> c) -> p d c
- cotabulated :: (Corepresentable p, Corepresentable q) => Iso (Corep p d -> c) (Corep q d' -> c') (p d c) (q d' c')
- unfirstCorep :: Corepresentable p => p (a, d) (b, d) -> p a b
- unsecondCorep :: Corepresentable p => p (d, a) (d, b) -> p a b
- data Prep p a where
  - Prep :: x -> p x a -> Prep p a
- prepAdj :: (forall a. Prep p a -> g a) -> p :-> Star g
- unprepAdj :: (p :-> Star g) -> Prep p a -> g a
- prepUnit :: p :-> Star (Prep p)
- prepCounit :: Prep (Star f) a -> f a
- newtype Coprep p a = Coprep {
  - runCoprep :: forall r. p a r -> r
  }
- coprepAdj :: (forall a. f a -> Coprep p a) -> p :-> Costar f
- uncoprepAdj :: (p :-> Costar f) -> f a -> Coprep p a
- coprepUnit :: p :-> Costar (Coprep p)
- coprepCounit :: f a -> Coprep (Costar f) a

# Representable Profunctors

class (Sieve p (Rep p), Strong p) => Representable p where Source

A `Profunctor` `p` is `Representable` if there exists a `Functor` `f` such that `p d c` is isomorphic to `d -> f c`.

Associated Types

type Rep p :: * -> * Source

Methods

tabulate :: (d -> Rep p c) -> p d c Source

Instances

Representable (->) Source |
(Monad m, Functor m) => Representable (Kleisli m) Source |
Representable (Forget r) Source |
Functor f => Representable (Star f) Source |
(Representable p, Representable q) => Representable (Procompose p q) Source | The composition of two `Representable` `Profunctor`s is `Representable` by the composition of their representations.

tabulated :: (Representable p, Representable q) => Iso (d -> Rep p c) (d' -> Rep q c') (p d c) (q d' c') Source

`tabulate` and `sieve` form two halves of an isomorphism.

This can be used with the combinators from the `lens` package.

    tabulated :: Representable p => Iso' (d -> Rep p c) (p d c)

firstRep :: Representable p => p a b -> p (a, c) (b, c) Source

Default definition for `first'` given that p is `Representable`.

secondRep :: Representable p => p a b -> p (c, a) (c, b) Source

Default definition for `second'` given that p is `Representable`.

# Corepresentable Profunctors

class (Cosieve p (Corep p), Costrong p) => Corepresentable p where Source

A `Profunctor` `p` is `Corepresentable` if there exists a `Functor` `f` such that `p d c` is isomorphic to `f d -> c`.

Associated Types

type Corep p :: * -> * Source

Methods

cotabulate :: (Corep p d -> c) -> p d c Source

Instances

Corepresentable (->) Source |
Functor w => Corepresentable (Cokleisli w) Source |
Corepresentable (Tagged *) Source |
Functor f => Corepresentable (Costar f) Source |
(Corepresentable p, Corepresentable q) => Corepresentable (Procompose p q) Source |

cotabulated :: (Corepresentable p, Corepresentable q) => Iso (Corep p d -> c) (Corep q d' -> c') (p d c) (q d' c') Source

`cotabulate` and `cosieve` form two halves of an isomorphism.

This can be used with the combinators from the `lens` package.

    cotabulated :: Corep f p => Iso' (f d -> c) (p d c)

unfirstCorep :: Corepresentable p => p (a, d) (b, d) -> p a b Source

Default definition for `unfirst` given that p is `Corepresentable`.

unsecondCorep :: Corepresentable p => p (d, a) (d, b) -> p a b Source

Default definition for `unsecond` given that p is `Corepresentable`.

# Prep -| Star

data Prep p a where Source

    Prep -| Star :: [Hask, Hask] -> Prof

This gives rise to a monad in `Prof`, `('Star'.'Prep')`, and a comonad in `[Hask,Hask]` `('Prep'.'Star')`

Constructors

Prep :: x -> p x a -> Prep p a |

Instances

(Monad (Rep p), Representable p) => Monad (Prep p) Source |
Profunctor p => Functor (Prep p) Source |
(Applicative (Rep p), Representable p) => Applicative (Prep p) Source |

prepAdj :: (forall a. Prep p a -> g a) -> p :-> Star g Source

unprepAdj :: (p :-> Star g) -> Prep p a -> g a Source

prepUnit :: p :-> Star (Prep p) Source

prepCounit :: Prep (Star f) a -> f a Source

# Coprep -| Costar

newtype Coprep p a Source

Constructors

Coprep |

Fields

runCoprep :: forall r. p a r -> r

Instances

Profunctor p => Functor (Coprep p) Source |

coprepAdj :: (forall a. f a -> Coprep p a) -> p :-> Costar f Source

    Coprep -| Costar :: [Hask, Hask]^op -> Prof

Like all adjunctions this gives rise to a monad and a comonad.

This gives rise to a monad on Prof `('Costar'.'Coprep')` and a comonad on `[Hask, Hask]^op` given by `('Coprep'.'Costar')` which is a monad in `[Hask,Hask]`

uncoprepAdj :: (p :-> Costar f) -> f a -> Coprep p a Source

coprepUnit :: p :-> Costar (Coprep p) Source

coprepCounit :: f a -> Coprep (Costar f) a Source