Data.Functor.Rep

Description

Synopsis

# Representable Functors

class Distributive f => Representable f 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


Associated Types

type Rep f :: * Source #

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

Methods

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

fmap f . tabulate ≡ tabulate . fmap f


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

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

fmap f . tabulate ≡ tabulate . fmap f


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

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

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

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

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

Instances

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 a Source #

Constructors

 Co FieldsunCo :: f a

Instances

 Source # Methodslower :: Comonad w => Co w a -> w a # (Representable f, (~) * (Rep f) a) => MonadReader a (Co f) Source # Methodsask :: Co f a #local :: (a -> a) -> Co f a -> Co f a #reader :: (a -> a) -> Co f a # Representable f => Monad (Co f) Source # Methods(>>=) :: Co f a -> (a -> Co f b) -> Co f b #(>>) :: Co f a -> Co f b -> Co f b #return :: a -> Co f a #fail :: String -> Co f a # Functor f => Functor (Co f) Source # Methodsfmap :: (a -> b) -> Co f a -> Co f b #(<\$) :: a -> Co f b -> Co f a # Representable f => Applicative (Co f) Source # Methodspure :: a -> Co f a #(<*>) :: Co f (a -> b) -> Co f a -> Co f b #liftA2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c #(*>) :: Co f a -> Co f b -> Co f b #(<*) :: Co f a -> Co f b -> Co f a # (Representable f, Monoid (Rep f)) => Comonad (Co f) Source # Methodsextract :: Co f a -> a #duplicate :: Co f a -> Co f (Co f a) #extend :: (Co f a -> b) -> Co f a -> Co f b # Representable f => Distributive (Co f) Source # Methodsdistribute :: Functor f => f (Co f a) -> Co f (f a) #collect :: Functor f => (a -> Co f b) -> f a -> Co f (f b) #distributeM :: Monad m => m (Co f a) -> Co f (m a) #collectM :: Monad m => (a -> Co f b) -> m a -> Co f (m b) # Representable f => Apply (Co f) Source # Methods(<.>) :: Co f (a -> b) -> Co f a -> Co f b #(.>) :: Co f a -> Co f b -> Co f b #(<.) :: Co f a -> Co f b -> Co f a #liftF2 :: (a -> b -> c) -> Co f a -> Co f b -> Co f c # Representable f => Bind (Co f) Source # Methods(>>-) :: Co f a -> (a -> Co f b) -> Co f b #join :: Co f (Co f a) -> Co f a # (Representable f, Semigroup (Rep f)) => Extend (Co f) Source # Methodsduplicated :: Co f a -> Co f (Co f a) #extended :: (Co f a -> b) -> Co f a -> Co f b # Representable f => Representable (Co f) Source # Associated Typestype Rep (Co f :: * -> *) :: * Source # Methodstabulate :: (Rep (Co f) -> a) -> Co f a Source #index :: Co f a -> Rep (Co f) -> a Source # type Rep (Co f) Source # 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 #

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

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

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

mzipWithRep :: Representable f => (a -> b -> c) -> f a -> f b -> f c 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 #

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 #

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 :: forall r m a. (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m Source #

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

## Generics

type GRep f = 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 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 FieldsunwrapRep :: Rep f