adjunctions-4.4.3: Adjunctions and representable functors

Copyright | (c) Edward Kmett 2011-2014
License | BSD3
Maintainer | ekmett@gmail.com
Stability | experimental
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Functor.Rep

Contents

- Representable Functors
- Wrapped representable functors
- Default definitions
  - Functor
  - Distributive
  - Apply/Applicative
  - Bind/Monad
  - MonadFix
  - MonadZip
  - MonadReader
  - Extend
  - Comonad
  - Comonad, with user-specified monoid
  - WithIndex
  - Generics

Description

Representable endofunctors over the category of Haskell types are isomorphic to the reader monad and so inherit a very large number of properties for free.

Synopsis

- class Distributive f => Representable (f :: Type -> Type) where
  - type Rep (f :: Type -> Type)
  - tabulate :: (Rep f -> a) -> f a
  - index :: f a -> Rep f -> a
- tabulated :: (Representable f, Representable g, Profunctor p, Functor h) => p (f a) (h (g b)) -> p (Rep f -> a) (h (Rep g -> b))
- newtype Co (f :: Type -> Type) a = Co {
  - unCo :: f a
  }
- fmapRep :: Representable f => (a -> b) -> f a -> f b
- distributeRep :: (Representable f, Functor w) => w (f a) -> f (w a)
- collectRep :: (Representable f, Functor w) => (a -> f b) -> w a -> f (w b)
- apRep :: Representable f => f (a -> b) -> f a -> f b
- pureRep :: Representable f => a -> f a
- liftR2 :: Representable f => (a -> b -> c) -> f a -> f b -> f c
- liftR3 :: Representable f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- bindRep :: Representable f => f a -> (a -> f b) -> f b
- mfixRep :: Representable f => (a -> f a) -> f a
- mzipRep :: Representable f => f a -> f b -> f (a, b)
- mzipWithRep :: Representable f => (a -> b -> c) -> f a -> f b -> f c
- askRep :: Representable f => f (Rep f)
- localRep :: Representable f => (Rep f -> Rep f) -> f a -> f a
- duplicatedRep :: (Representable f, Semigroup (Rep f)) => f a -> f (f a)
- extendedRep :: (Representable f, Semigroup (Rep f)) => (f a -> b) -> f a -> f b
- duplicateRep :: (Representable f, Monoid (Rep f)) => f a -> f (f a)
- extendRep :: (Representable f, Monoid (Rep f)) => (f a -> b) -> f a -> f b
- extractRep :: (Representable f, Monoid (Rep f)) => f a -> a
- duplicateRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> f a -> f (f a)
- extendRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> (f a -> b) -> f a -> f b
- extractRepBy :: Representable f => Rep f -> f a -> a
- imapRep :: Representable r => (Rep r -> a -> a') -> r a -> r a'
- ifoldMapRep :: (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m
- itraverseRep :: (Representable r, Traversable r, Applicative f) => (Rep r -> a -> f a') -> r a -> f (r a')
- type GRep (f :: Type -> Type) = GRep' (Rep1 f)
- gindex :: (Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f)) => f a -> Rep f -> a
- gtabulate :: (Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f)) => (Rep f -> a) -> f a
- newtype WrappedRep (f :: Type -> Type) = WrapRep {
  - unwrapRep :: Rep f
  }

# Representable Functors

class Distributive f => Representable (f :: Type -> Type) where Source #

A `Functor` `f` is `Representable` if `tabulate` and `index` witness an isomorphism to `(->) x`.

Every `Distributive` `Functor` is actually `Representable`.

Every `Representable` `Functor` from Hask to Hask is a right adjoint.

    tabulate . index  ≡ id
    index . tabulate  ≡ id
    tabulate . return ≡ return

Minimal complete definition

Nothing

Associated Types

type Rep (f :: Type -> Type) Source #

If no definition is provided, this will default to `GRep`.

type Rep (f :: Type -> Type) = GRep f

Methods

tabulate :: (Rep f -> a) -> f a Source #

    fmap f . tabulate ≡ tabulate . fmap f

If no definition is provided, this will default to `gtabulate`.

default tabulate :: (Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f)) => (Rep f -> a) -> f a Source #

index :: f a -> Rep f -> a Source #

If no definition is provided, this will default to `gindex`.

default index :: (Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f)) => f a -> Rep f -> a Source #

#### Instances

Instances details

Representable Complex Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Complex |
Instance details Defined in Data.Functor.Rep type Rep Complex = Bool

Methods

tabulate :: (Rep Complex -> a) -> Complex a Source #

index :: Complex a -> Rep Complex -> a Source #

Representable Identity Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Identity |
Instance details Defined in Data.Functor.Rep type Rep Identity = ()

Methods

tabulate :: (Rep Identity -> a) -> Identity a Source #

index :: Identity a -> Rep Identity -> a Source #

Representable Dual Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Dual |
Instance details Defined in Data.Functor.Rep type Rep Dual = ()

Methods

tabulate :: (Rep Dual -> a) -> Dual a Source #

index :: Dual a -> Rep Dual -> a Source #

Representable Product Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Product |
Instance details Defined in Data.Functor.Rep type Rep Product = ()

Methods

tabulate :: (Rep Product -> a) -> Product a Source #

index :: Product a -> Rep Product -> a Source #

Representable Sum Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Sum |
Instance details Defined in Data.Functor.Rep type Rep Sum = ()

Methods

tabulate :: (Rep Sum -> a) -> Sum a Source #

index :: Sum a -> Rep Sum -> a Source #

Representable Par1 Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep Par1 |
Instance details Defined in Data.Functor.Rep type Rep Par1 = ()

Methods

tabulate :: (Rep Par1 -> a) -> Par1 a Source #

index :: Par1 a -> Rep Par1 -> a Source #

Representable f => Representable (Co f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Co f) |
Instance details Defined in Data.Functor.Rep type Rep (Co f) = Rep f

Methods

tabulate :: (Rep (Co f) -> a) -> Co f a Source #

index :: Co f a -> Rep (Co f) -> a Source #

Representable f => Representable (Cofree f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Cofree f) |
Instance details Defined in Data.Functor.Rep type Rep (Cofree f) = Seq (Rep f)

Methods

tabulate :: (Rep (Cofree f) -> a) -> Cofree f a Source #

index :: Cofree f a -> Rep (Cofree f) -> a Source #

Representable (Proxy :: Type -> Type) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Proxy :: Type -> Type) |
Instance details Defined in Data.Functor.Rep type Rep (Proxy :: Type -> Type) = Void

Methods

tabulate :: (Rep (Proxy :: Type -> Type) -> a) -> Proxy a Source #

index :: Proxy a -> Rep (Proxy :: Type -> Type) -> a Source #

Representable (U1 :: Type -> Type) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (U1 :: Type -> Type) |
Instance details Defined in Data.Functor.Rep type Rep (U1 :: Type -> Type) = Void

Methods

tabulate :: (Rep (U1 :: Type -> Type) -> a) -> U1 a Source #

index :: U1 a -> Rep (U1 :: Type -> Type) -> a Source #

(Representable f, Representable m) => Representable (ReaderT f m) Source # |

Instance details

Defined in Control.Monad.Representable.Reader

Associated Types

type Rep (ReaderT f m) |
Instance details Defined in Control.Monad.Representable.Reader type Rep (ReaderT f m) = (Rep f, Rep m)

Methods

tabulate :: (Rep (ReaderT f m) -> a) -> ReaderT f m a Source #

index :: ReaderT f m a -> Rep (ReaderT f m) -> a Source #

Representable w => Representable (TracedT s w) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (TracedT s w) |
Instance details Defined in Data.Functor.Rep type Rep (TracedT s w) = (s, Rep w)

Methods

tabulate :: (Rep (TracedT s w) -> a) -> TracedT s w a Source #

index :: TracedT s w a -> Rep (TracedT s w) -> a Source #

Representable f => Representable (Rec1 f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Rec1 f) |
Instance details Defined in Data.Functor.Rep type Rep (Rec1 f) = Rep f

Methods

tabulate :: (Rep (Rec1 f) -> a) -> Rec1 f a Source #

index :: Rec1 f a -> Rep (Rec1 f) -> a Source #

Representable (Tagged t) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Tagged t) |
Instance details Defined in Data.Functor.Rep type Rep (Tagged t) = ()

Methods

tabulate :: (Rep (Tagged t) -> a) -> Tagged t a Source #

index :: Tagged t a -> Rep (Tagged t) -> a Source #

Representable f => Representable (Backwards f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Backwards f) |
Instance details Defined in Data.Functor.Rep type Rep (Backwards f) = Rep f

Methods

tabulate :: (Rep (Backwards f) -> a) -> Backwards f a Source #

index :: Backwards f a -> Rep (Backwards f) -> a Source #

Representable m => Representable (IdentityT m) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (IdentityT m) |
Instance details Defined in Data.Functor.Rep type Rep (IdentityT m) = Rep m

Methods

tabulate :: (Rep (IdentityT m) -> a) -> IdentityT m a Source #

index :: IdentityT m a -> Rep (IdentityT m) -> a Source #

Representable m => Representable (ReaderT e m) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (ReaderT e m) |
Instance details Defined in Data.Functor.Rep type Rep (ReaderT e m) = (e, Rep m)

Methods

tabulate :: (Rep (ReaderT e m) -> a) -> ReaderT e m a Source #

index :: ReaderT e m a -> Rep (ReaderT e m) -> a Source #

Representable f => Representable (Reverse f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Reverse f) |
Instance details Defined in Data.Functor.Rep type Rep (Reverse f) = Rep f

Methods

tabulate :: (Rep (Reverse f) -> a) -> Reverse f a Source #

index :: Reverse f a -> Rep (Reverse f) -> a Source #

(Representable f, Representable g) => Representable (Product f g) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Product f g) |
Instance details Defined in Data.Functor.Rep type Rep (Product f g) = Either (Rep f) (Rep g)

Methods

tabulate :: (Rep (Product f g) -> a) -> Product f g a Source #

index :: Product f g a -> Rep (Product f g) -> a Source #

(Representable f, Representable g) => Representable (f :*: g) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (f :*: g) |
Instance details Defined in Data.Functor.Rep type Rep (f :*: g) = Either (Rep f) (Rep g)

Methods

tabulate :: (Rep (f :*: g) -> a) -> (f :*: g) a Source #

index :: (f :*: g) a -> Rep (f :*: g) -> a Source #

Representable ((->) e) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep ((->) e) |
Instance details Defined in Data.Functor.Rep type Rep ((->) e) = e

Methods

tabulate :: (Rep ((->) e) -> a) -> e -> a Source #

index :: (e -> a) -> Rep ((->) e) -> a Source #

(Representable f, Representable g) => Representable (Compose f g) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Compose f g) |
Instance details Defined in Data.Functor.Rep type Rep (Compose f g) = (Rep f, Rep g)

Methods

tabulate :: (Rep (Compose f g) -> a) -> Compose f g a Source #

index :: Compose f g a -> Rep (Compose f g) -> a Source #

(Representable f, Representable g) => Representable (f :.: g) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (f :.: g) |
Instance details Defined in Data.Functor.Rep type Rep (f :.: g) = (Rep f, Rep g)

Methods

tabulate :: (Rep (f :.: g) -> a) -> (f :.: g) a Source #

index :: (f :.: g) a -> Rep (f :.: g) -> a Source #

Representable f => Representable (M1 i c f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (M1 i c f) |
Instance details Defined in Data.Functor.Rep type Rep (M1 i c f) = Rep f

Methods

tabulate :: (Rep (M1 i c f) -> a) -> M1 i c f a Source #

index :: M1 i c f a -> Rep (M1 i c f) -> a Source #

tabulated :: (Representable f, Representable g, Profunctor p, Functor h) => p (f a) (h (g b)) -> p (Rep f -> a) (h (Rep g -> b)) Source #

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

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

    tabulated :: Representable f => Iso' (Rep f -> a) (f a)

# Wrapped representable functors

newtype Co (f :: Type -> Type) a Source #

Constructors

Co |

Fields

- unCo :: f a

#### Instances

Instances details

ComonadTrans Co Source # |
Instance details Defined in Data.Functor.Rep Methods lower :: Comonad w => Co w a -> w a Source #
(Representable f, Rep f ~ a) => MonadReader a (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods ask :: Co f a Source # local :: (a -> a) -> Co f a0 -> Co f a0 Source # reader :: (a -> a0) -> Co f a0 Source #
Representable f => Representable (Co f) Source # |

Instance details

Defined in Data.Functor.Rep

Associated Types

type Rep (Co f) |
Instance details Defined in Data.Functor.Rep type Rep (Co f) = Rep f

Methods

tabulate :: (Rep (Co f) -> a) -> Co f a Source #

index :: Co f a -> Rep (Co f) -> a Source #

(Representable f, Monoid (Rep f)) => Comonad (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods extract :: Co f a -> a Source # duplicate :: Co f a -> Co f (Co f a) Source # extend :: (Co f a -> b) -> Co f a -> Co f b Source #
Representable f => Distributive (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods distribute :: Functor f0 => f0 (Co f a) -> Co f (f0 a) Source # collect :: Functor f0 => (a -> Co f b) -> f0 a -> Co f (f0 b) Source # distributeM :: Monad m => m (Co f a) -> Co f (m a) Source # collectM :: Monad m => (a -> Co f b) -> m a -> Co f (m b) Source #
Representable f => Applicative (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods pure :: a -> Co f a Source # (<*>) :: Co f (a -> b) -> Co f a -> Co f b Source # liftA2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c Source # (*>) :: Co f a -> Co f b -> Co f b Source # (<*) :: Co f a -> Co f b -> Co f a Source #
Functor f => Functor (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods fmap :: (a -> b) -> Co f a -> Co f b Source # (<$) :: a -> Co f b -> Co f a Source #
Representable f => Monad (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods (>>=) :: Co f a -> (a -> Co f b) -> Co f b Source # (>>) :: Co f a -> Co f b -> Co f b Source # return :: a -> Co f a Source #
Representable f => Apply (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods (<.>) :: Co f (a -> b) -> Co f a -> Co f b Source # (.>) :: Co f a -> Co f b -> Co f b Source # (<.) :: Co f a -> Co f b -> Co f a Source # liftF2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c Source #
Representable f => Bind (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods (>>-) :: Co f a -> (a -> Co f b) -> Co f b Source # join :: Co f (Co f a) -> Co f a Source #
(Representable f, Semigroup (Rep f)) => Extend (Co f) Source # |
Instance details Defined in Data.Functor.Rep Methods duplicated :: Co f a -> Co f (Co f a) Source # extended :: (Co f a -> b) -> Co f a -> Co f b Source #
type Rep (Co f) Source # |
Instance details Defined in Data.Functor.Rep type Rep (Co f) = Rep f

# Default definitions

## Functor

fmapRep :: Representable f => (a -> b) -> f a -> f b Source #

## Distributive

distributeRep :: (Representable f, Functor w) => w (f a) -> f (w a) Source #

collectRep :: (Representable f, Functor w) => (a -> f b) -> w a -> f (w b) Source #

## Apply/Applicative

apRep :: Representable f => f (a -> b) -> f a -> f b Source #

pureRep :: Representable f => a -> f a Source #

liftR2 :: Representable f => (a -> b -> c) -> f a -> f b -> f c Source #

liftR3 :: Representable f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source #

## Bind/Monad

bindRep :: Representable f => f a -> (a -> f b) -> f b Source #

## MonadFix

mfixRep :: Representable f => (a -> f a) -> f a Source #

## MonadZip

mzipRep :: Representable f => f a -> f b -> f (a, b) Source #

mzipWithRep :: Representable f => (a -> b -> c) -> f a -> f b -> f c Source #

## MonadReader

askRep :: Representable f => f (Rep f) Source #

localRep :: Representable f => (Rep f -> Rep f) -> f a -> f a Source #

## Extend

duplicatedRep :: (Representable f, Semigroup (Rep f)) => f a -> f (f a) Source #

extendedRep :: (Representable f, Semigroup (Rep f)) => (f a -> b) -> f a -> f b Source #

## Comonad

duplicateRep :: (Representable f, Monoid (Rep f)) => f a -> f (f a) Source #

extendRep :: (Representable f, Monoid (Rep f)) => (f a -> b) -> f a -> f b Source #

extractRep :: (Representable f, Monoid (Rep f)) => f a -> a Source #

## Comonad, with user-specified monoid

duplicateRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> f a -> f (f a) Source #

extendRepBy :: Representable f => (Rep f -> Rep f -> Rep f) -> (f a -> b) -> f a -> f b Source #

extractRepBy :: Representable f => Rep f -> f a -> a Source #

## WithIndex

imapRep :: Representable r => (Rep r -> a -> a') -> r a -> r a' Source #

ifoldMapRep :: (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m Source #

itraverseRep :: (Representable r, Traversable r, Applicative f) => (Rep r -> a -> f a') -> r a -> f (r a') Source #

## Generics

type GRep (f :: Type -> Type) = GRep' (Rep1 f) Source #

A default implementation of `Rep` for a datatype that is an instance of `Generic1`. This is usually composed of `Either`, tuples, unit tuples, and underlying `Rep` values. For instance, if you have:

    data Foo a = MkFoo a (Bar a) (Baz (Quux a)) deriving (Functor, Generic1)
    instance Representable Foo

Then you'll get:

    GRep Foo = Either () (Either (WrappedRep Bar) (WrappedRep Baz, WrappedRep Quux))

(See the Haddocks for `WrappedRep` for an explanation of its purpose.)

gindex :: (Generic1 f, GRep f ~ Rep f, GIndex (Rep1 f)) => f a -> Rep f -> a Source #

A default implementation of `index` in terms of `GRep`.

gtabulate :: (Generic1 f, GRep f ~ Rep f, GTabulate (Rep1 f)) => (Rep f -> a) -> f a Source #

A default implementation of `tabulate` in terms of `GRep`.

newtype WrappedRep (f :: Type -> Type) Source #

On the surface, `WrappedRec` is a simple wrapper around `Rep`. But it plays a very important role: it prevents generic `Representable` instances for recursive types from sending the typechecker into an infinite loop. Consider the following datatype:

    data Stream a = a :< Stream a deriving (Functor, Generic1)
    instance Representable Stream

With `WrappedRep`, we have its `Rep` being:

    Rep Stream = Either () (WrappedRep Stream)

If `WrappedRep` didn't exist, it would be:

    Rep Stream = Either () (Either () (Either () ...))

An infinite type! `WrappedRep` breaks the potentially infinite loop.

Constructors

WrapRep |

Fields

- unwrapRep :: Rep f