kan-extensions-5.2.6: Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads
Copyright(C) 2011-2016 Edward Kmett
LicenseBSD-style (see the file LICENSE)
MaintainerEdward Kmett <ekmett@gmail.com>
Stabilityprovisional
PortabilityGADTs, MPTCs, fundeps
Safe HaskellTrustworthy
LanguageHaskell2010

Data.Functor.Coyoneda

Description

Coyoneda f is the "free functor" over f. The co-Yoneda lemma for a covariant Functor f states that Coyoneda f is naturally isomorphic to f.

Synopsis

Documentation

data Coyoneda f a where Source #

A covariant Functor suitable for Yoneda reduction

Constructors

Coyoneda :: (b -> a) -> f b -> Coyoneda f a 

Instances

Instances details
ComonadTrans Coyoneda Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

lower :: Comonad w => Coyoneda w a -> w a Source #

MonadTrans Coyoneda Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

lift :: Monad m => m a -> Coyoneda m a #

Representable f => Representable (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Associated Types

type Rep (Coyoneda f) Source #

Methods

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

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

MonadFix f => MonadFix (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

mfix :: (a -> Coyoneda f a) -> Coyoneda f a #

Foldable f => Foldable (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

fold :: Monoid m => Coyoneda f m -> m #

foldMap :: Monoid m => (a -> m) -> Coyoneda f a -> m #

foldMap' :: Monoid m => (a -> m) -> Coyoneda f a -> m #

foldr :: (a -> b -> b) -> b -> Coyoneda f a -> b #

foldr' :: (a -> b -> b) -> b -> Coyoneda f a -> b #

foldl :: (b -> a -> b) -> b -> Coyoneda f a -> b #

foldl' :: (b -> a -> b) -> b -> Coyoneda f a -> b #

foldr1 :: (a -> a -> a) -> Coyoneda f a -> a #

foldl1 :: (a -> a -> a) -> Coyoneda f a -> a #

toList :: Coyoneda f a -> [a] #

null :: Coyoneda f a -> Bool #

length :: Coyoneda f a -> Int #

elem :: Eq a => a -> Coyoneda f a -> Bool #

maximum :: Ord a => Coyoneda f a -> a #

minimum :: Ord a => Coyoneda f a -> a #

sum :: Num a => Coyoneda f a -> a #

product :: Num a => Coyoneda f a -> a #

Foldable1 f => Foldable1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

fold1 :: Semigroup m => Coyoneda f m -> m #

foldMap1 :: Semigroup m => (a -> m) -> Coyoneda f a -> m #

foldMap1' :: Semigroup m => (a -> m) -> Coyoneda f a -> m #

toNonEmpty :: Coyoneda f a -> NonEmpty a #

maximum :: Ord a => Coyoneda f a -> a #

minimum :: Ord a => Coyoneda f a -> a #

head :: Coyoneda f a -> a #

last :: Coyoneda f a -> a #

foldrMap1 :: (a -> b) -> (a -> b -> b) -> Coyoneda f a -> b #

foldlMap1' :: (a -> b) -> (b -> a -> b) -> Coyoneda f a -> b #

foldlMap1 :: (a -> b) -> (b -> a -> b) -> Coyoneda f a -> b #

foldrMap1' :: (a -> b) -> (a -> b -> b) -> Coyoneda f a -> b #

Eq1 f => Eq1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

liftEq :: (a -> b -> Bool) -> Coyoneda f a -> Coyoneda f b -> Bool #

Ord1 f => Ord1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

liftCompare :: (a -> b -> Ordering) -> Coyoneda f a -> Coyoneda f b -> Ordering #

Read1 f => Read1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Coyoneda f a) #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Coyoneda f a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Coyoneda f a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Coyoneda f a] #

(Functor f, Show1 f) => Show1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Coyoneda f a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Coyoneda f a] -> ShowS #

Traversable f => Traversable (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Coyoneda f a -> f0 (Coyoneda f b) #

sequenceA :: Applicative f0 => Coyoneda f (f0 a) -> f0 (Coyoneda f a) #

mapM :: Monad m => (a -> m b) -> Coyoneda f a -> m (Coyoneda f b) #

sequence :: Monad m => Coyoneda f (m a) -> m (Coyoneda f a) #

Alternative f => Alternative (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

empty :: Coyoneda f a #

(<|>) :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a #

some :: Coyoneda f a -> Coyoneda f [a] #

many :: Coyoneda f a -> Coyoneda f [a] #

Applicative f => Applicative (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

pure :: a -> Coyoneda f a #

(<*>) :: Coyoneda f (a -> b) -> Coyoneda f a -> Coyoneda f b #

liftA2 :: (a -> b -> c) -> Coyoneda f a -> Coyoneda f b -> Coyoneda f c #

(*>) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f b #

(<*) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f a #

Functor (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

fmap :: (a -> b) -> Coyoneda f a -> Coyoneda f b #

(<$) :: a -> Coyoneda f b -> Coyoneda f a #

Monad m => Monad (Coyoneda m) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

(>>=) :: Coyoneda m a -> (a -> Coyoneda m b) -> Coyoneda m b #

(>>) :: Coyoneda m a -> Coyoneda m b -> Coyoneda m b #

return :: a -> Coyoneda m a #

MonadPlus f => MonadPlus (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

mzero :: Coyoneda f a #

mplus :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a #

Comonad w => Comonad (Coyoneda w) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

extract :: Coyoneda w a -> a Source #

duplicate :: Coyoneda w a -> Coyoneda w (Coyoneda w a) Source #

extend :: (Coyoneda w a -> b) -> Coyoneda w a -> Coyoneda w b Source #

Distributive f => Distributive (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

distribute :: Functor f0 => f0 (Coyoneda f a) -> Coyoneda f (f0 a) Source #

collect :: Functor f0 => (a -> Coyoneda f b) -> f0 a -> Coyoneda f (f0 b) Source #

distributeM :: Monad m => m (Coyoneda f a) -> Coyoneda f (m a) Source #

collectM :: Monad m => (a -> Coyoneda f b) -> m a -> Coyoneda f (m b) Source #

Alt f => Alt (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

(<!>) :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a Source #

some :: Applicative (Coyoneda f) => Coyoneda f a -> Coyoneda f [a] Source #

many :: Applicative (Coyoneda f) => Coyoneda f a -> Coyoneda f [a] Source #

Apply f => Apply (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

(<.>) :: Coyoneda f (a -> b) -> Coyoneda f a -> Coyoneda f b Source #

(.>) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f b Source #

(<.) :: Coyoneda f a -> Coyoneda f b -> Coyoneda f a Source #

liftF2 :: (a -> b -> c) -> Coyoneda f a -> Coyoneda f b -> Coyoneda f c Source #

Bind m => Bind (Coyoneda m) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

(>>-) :: Coyoneda m a -> (a -> Coyoneda m b) -> Coyoneda m b Source #

join :: Coyoneda m (Coyoneda m a) -> Coyoneda m a Source #

Extend w => Extend (Coyoneda w) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

duplicated :: Coyoneda w a -> Coyoneda w (Coyoneda w a) Source #

extended :: (Coyoneda w a -> b) -> Coyoneda w a -> Coyoneda w b Source #

Plus f => Plus (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

zero :: Coyoneda f a Source #

Traversable1 f => Traversable1 (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

traverse1 :: Apply f0 => (a -> f0 b) -> Coyoneda f a -> f0 (Coyoneda f b) Source #

sequence1 :: Apply f0 => Coyoneda f (f0 b) -> f0 (Coyoneda f b) Source #

Adjunction f g => Adjunction (Coyoneda f) (Coyoneda g) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

unit :: a -> Coyoneda g (Coyoneda f a) Source #

counit :: Coyoneda f (Coyoneda g a) -> a Source #

leftAdjunct :: (Coyoneda f a -> b) -> a -> Coyoneda g b Source #

rightAdjunct :: (a -> Coyoneda g b) -> Coyoneda f a -> b Source #

Read (f a) => Read (Coyoneda f a) Source # 
Instance details

Defined in Data.Functor.Coyoneda

(Functor f, Show1 f, Show a) => Show (Coyoneda f a) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

showsPrec :: Int -> Coyoneda f a -> ShowS #

show :: Coyoneda f a -> String #

showList :: [Coyoneda f a] -> ShowS #

(Eq1 f, Eq a) => Eq (Coyoneda f a) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

(==) :: Coyoneda f a -> Coyoneda f a -> Bool #

(/=) :: Coyoneda f a -> Coyoneda f a -> Bool #

(Ord1 f, Ord a) => Ord (Coyoneda f a) Source # 
Instance details

Defined in Data.Functor.Coyoneda

Methods

compare :: Coyoneda f a -> Coyoneda f a -> Ordering #

(<) :: Coyoneda f a -> Coyoneda f a -> Bool #

(<=) :: Coyoneda f a -> Coyoneda f a -> Bool #

(>) :: Coyoneda f a -> Coyoneda f a -> Bool #

(>=) :: Coyoneda f a -> Coyoneda f a -> Bool #

max :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a #

min :: Coyoneda f a -> Coyoneda f a -> Coyoneda f a #

type Rep (Coyoneda f) Source # 
Instance details

Defined in Data.Functor.Coyoneda

type Rep (Coyoneda f) = Rep f

liftCoyoneda :: f a -> Coyoneda f a Source #

Yoneda "expansion"

liftCoyoneda . lowerCoyonedaid
lowerCoyoneda . liftCoyonedaid
lowerCoyoneda (liftCoyoneda fa) = -- by definition
lowerCoyoneda (Coyoneda id fa)  = -- by definition
fmap id fa                      = -- functor law
fa
lift = liftCoyoneda

lowerCoyoneda :: Functor f => Coyoneda f a -> f a Source #

Yoneda reduction lets us walk under the existential and apply fmap.

Mnemonically, "Yoneda reduction" sounds like and works a bit like β-reduction.

http://ncatlab.org/nlab/show/Yoneda+reduction

You can view Coyoneda as just the arguments to fmap tupled up.

lower = lowerM = lowerCoyoneda

lowerM :: Monad f => Coyoneda f a -> f a Source #

Yoneda reduction given a Monad lets us walk under the existential and apply liftM.

You can view Coyoneda as just the arguments to liftM tupled up.

lower = lowerM = lowerCoyoneda

hoistCoyoneda :: (forall a. f a -> g a) -> Coyoneda f b -> Coyoneda g b Source #

Lift a natural transformation from f to g to a natural transformation from Coyoneda f to Coyoneda g.

as a Left Kan extension

coyonedaToLan :: Coyoneda f a -> Lan Identity f a Source #

Coyoneda f is the left Kan extension of f along the Identity functor.

Coyoneda f is always a functor, even if f is not. In this case, it is called the free functor over f. Note the following categorical fine print: If f is not a functor, Coyoneda f is actually not the left Kan extension of f along the Identity functor, but along the inclusion functor from the discrete subcategory of Hask which contains only identity functions as morphisms to the full category Hask. (This is because f, not being a proper functor, can only be interpreted as a categorical functor by restricting the source category to only contain identities.)

coyonedaToLan . lanToCoyonedaid
lanToCoyoneda . coyonedaToLanid