Data.Functor.Rep

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.

Representable Functors

class Distributive f => Representable f where

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 :: *

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

Methods

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

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

fmap f . tabulate ≡ tabulate . fmap f

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

index :: f a -> Rep f -> a

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

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

Instances

Representable Par1

Associated Types

type Rep (Par1 :: * -> *) :: *

Methods

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

index :: Par1 a -> Rep Par1 -> a

Representable Complex

Associated Types

type Rep (Complex :: * -> *) :: *

Methods

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

index :: Complex a -> Rep Complex -> a

Representable Identity

Associated Types

type Rep (Identity :: * -> *) :: *

Methods

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

index :: Identity a -> Rep Identity -> a

Representable Dual

Associated Types

type Rep (Dual :: * -> *) :: *

Methods

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

index :: Dual a -> Rep Dual -> a

Representable Sum

Associated Types

type Rep (Sum :: * -> *) :: *

Methods

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

index :: Sum a -> Rep Sum -> a

Representable Product

Associated Types

type Rep (Product :: * -> *) :: *

Methods

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

index :: Product a -> Rep Product -> a

Representable (U1 *)

Associated Types

type Rep (U1 * :: * -> *) :: *

Methods

tabulate :: (Rep (U1 *) -> a) -> U1 * a

index :: U1 * a -> Rep (U1 *) -> a

Representable (Proxy *)

Associated Types

type Rep (Proxy * :: * -> *) :: *

Methods

tabulate :: (Rep (Proxy *) -> a) -> Proxy * a

index :: Proxy * a -> Rep (Proxy *) -> a

Representable f => Representable (Cofree f)

Associated Types

type Rep (Cofree f :: * -> *) :: *

Methods

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

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

Representable f => Representable (Co f)

Associated Types

type Rep (Co f :: * -> *) :: *

Methods

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

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

Representable f => Representable (Rec1 * f)

Associated Types

type Rep (Rec1 * f :: * -> *) :: *

Methods

tabulate :: (Rep (Rec1 * f) -> a) -> Rec1 * f a

index :: Rec1 * f a -> Rep (Rec1 * f) -> a

Representable w => Representable (TracedT s w)

Associated Types

type Rep (TracedT s w :: * -> *) :: *

Methods

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

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

Representable m => Representable (IdentityT * m)

Associated Types

type Rep (IdentityT * m :: * -> *) :: *

Methods

tabulate :: (Rep (IdentityT * m) -> a) -> IdentityT * m a

index :: IdentityT * m a -> Rep (IdentityT * m) -> a

Representable (Tagged * t)

Associated Types

type Rep (Tagged * t :: * -> *) :: *

Methods

tabulate :: (Rep (Tagged * t) -> a) -> Tagged * t a

index :: Tagged * t a -> Rep (Tagged * t) -> a

Representable f => Representable (Reverse * f)

Associated Types

type Rep (Reverse * f :: * -> *) :: *

Methods

tabulate :: (Rep (Reverse * f) -> a) -> Reverse * f a

index :: Reverse * f a -> Rep (Reverse * f) -> a

Representable f => Representable (Backwards * f)

Associated Types

type Rep (Backwards * f :: * -> *) :: *

Methods

tabulate :: (Rep (Backwards * f) -> a) -> Backwards * f a

index :: Backwards * f a -> Rep (Backwards * f) -> a

(Representable f, Representable m) => Representable (ReaderT f m)

Associated Types

type Rep (ReaderT f m :: * -> *) :: *

Methods

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

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

Representable ((->) LiftedRep LiftedRep e)

Associated Types

type Rep ((LiftedRep -> LiftedRep) e :: * -> *) :: *

Methods

tabulate :: (Rep ((LiftedRep -> LiftedRep) e) -> a) -> (LiftedRep -> LiftedRep) e a

index :: (LiftedRep -> LiftedRep) e a -> Rep ((LiftedRep -> LiftedRep) e) -> a

(Representable f, Representable g) => Representable ((:*:) * f g)

Associated Types

type Rep ((* :*: f) g :: * -> *) :: *

Methods

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

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

(Representable f, Representable g) => Representable (Product * f g)

Associated Types

type Rep (Product * f g :: * -> *) :: *

Methods

tabulate :: (Rep (Product * f g) -> a) -> Product * f g a

index :: Product * f g a -> Rep (Product * f g) -> a

Representable m => Representable (ReaderT * e m)

Associated Types

type Rep (ReaderT * e m :: * -> *) :: *

Methods

tabulate :: (Rep (ReaderT * e m) -> a) -> ReaderT * e m a

index :: ReaderT * e m a -> Rep (ReaderT * e m) -> a

Representable f => Representable (M1 * i c f)

Associated Types

type Rep (M1 * i c f :: * -> *) :: *

Methods

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

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

(Representable f, Representable g) => Representable ((:.:) * * f g)

Associated Types

type Rep ((* :.: *) f g :: * -> *) :: *

Methods

tabulate :: (Rep ((* :.: *) f g) -> a) -> (* :.: *) f g a

index :: (* :.: *) f g a -> Rep ((* :.: *) f g) -> a

(Representable f, Representable g) => Representable (Compose * * f g)

Associated Types

type Rep (Compose * * f g :: * -> *) :: *

Methods

tabulate :: (Rep (Compose * * f g) -> a) -> Compose * * f g a

index :: Compose * * f g a -> Rep (Compose * * f g) -> a

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

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

Constructors

Co

Fields

• unCo :: f a

Instances

ComonadTrans Co

Methods

lower :: Comonad w => Co w a -> w a

(Representable f, (~) * (Rep f) a) => MonadReader a (Co f)

Methods

ask :: Co f a

local :: (a -> a) -> Co f a -> Co f a

reader :: (a -> a) -> Co f a

Representable f => Monad (Co f)

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)

Methods

fmap :: (a -> b) -> Co f a -> Co f b

(<$) :: a -> Co f b -> Co f a

Representable f => Applicative (Co f)

Methods

pure :: 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)

Methods

extract :: 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)

Methods

distribute :: 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)

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)

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)

Methods

duplicated :: Co f a -> Co f (Co f a)

extended :: (Co f a -> b) -> Co f a -> Co f b

Representable f => Representable (Co f)

Associated Types

type Rep (Co f :: * -> *) :: *

Methods

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

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

type Rep (Co f)

type Rep (Co f) = Rep f

Default definitions

Functor

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

Distributive

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

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

Apply/Applicative

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

Bind/Monad

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

MonadFix

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

MonadZip

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

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

MonadReader

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

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

Extend

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

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

Comonad

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

Comonad, with user-specified monoid

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

WithIndex

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

ifoldMapRep :: forall r m a. (Representable r, Foldable r, Monoid m) => (Rep r -> a -> m) -> r a -> m

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

Generics

type GRep f = GRep' (Rep1 f)

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

A default implementation of index in terms of GRep.

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

A default implementation of tabulate in terms of GRep.

newtype WrappedRep f

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