Copyright 2008-2013 Edward Kmett BSD Edward Kmett experimental rank 2 types, MPTCs, fundeps Trustworthy Haskell98

Description

Synopsis

# Documentation

class (Functor f, Representable u) => Adjunction f u | f -> u, u -> f where Source

Minimal definition: both `unit` and `counit` or both `leftAdjunct` and `rightAdjunct`, subject to the constraints imposed by the default definitions that the following laws should hold.

```unit = leftAdjunct id
leftAdjunct f = fmap f . unit
rightAdjunct f = counit . fmap f```

Any implementation is required to ensure that `leftAdjunct` and `rightAdjunct` witness an isomorphism from `Nat (f a, b)` to `Nat (a, g b)`

```rightAdjunct unit = id

Minimal complete definition

Nothing

Methods

unit :: a -> u (f a) Source

counit :: f (u a) -> a Source

leftAdjunct :: (f a -> b) -> a -> u b Source

rightAdjunct :: (a -> u b) -> f a -> b Source

Instances

adjuncted :: (Adjunction f u, Profunctor p, Functor g) => p (a -> u b) (g (c -> u d)) -> p (f a -> b) (g (f c -> d)) Source

`leftAdjunct` and `rightAdjunct` form two halves of an isomorphism.

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

``adjuncted` :: `Adjunction` f u => `Iso'` (f a -> b) (a -> u b)`

tabulateAdjunction :: Adjunction f u => (f () -> b) -> u b Source

Every right adjoint is representable by its left adjoint applied to a unit element

Use this definition and the primitives in Data.Functor.Representable to meet the requirements of the superclasses of Representable.

indexAdjunction :: Adjunction f u => u b -> f a -> b Source

This definition admits a default definition for the `index` method of 'Index", one of the superclasses of Representable.

zapWithAdjunction :: Adjunction f u => (a -> b -> c) -> u a -> f b -> c Source

zipR :: Adjunction f u => (u a, u b) -> u (a, b) Source

unzipR :: Functor u => u (a, b) -> (u a, u b) Source

Every functor in Haskell permits unzipping

unabsurdL :: Adjunction f u => f Void -> Void Source

A left adjoint must be inhabited, or we can derive bottom.

cozipL :: Adjunction f u => f (Either a b) -> Either (f a) (f b) Source

And a left adjoint must be inhabited by exactly one element

uncozipL :: Functor f => Either (f a) (f b) -> f (Either a b) Source

Every functor in Haskell permits `uncozipping`

extractL :: Adjunction f u => f a -> a Source

duplicateL :: Adjunction f u => f a -> f (f a) Source

splitL :: Adjunction f u => f a -> (a, f ()) Source

unsplitL :: Functor f => a -> f () -> f a Source