-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Kan extensions, the Yoneda lemma, and (co)density (co)monads
--   
--   Kan extensions, the Yoneda lemma, and (co)density (co)monads
@package kan-extensions
@version 2.2


module Data.Functor.Yoneda.Contravariant

-- | The contravariant Yoneda lemma applied to a covariant functor
data Yoneda f a
Yoneda :: (b -> a) -> f b -> Yoneda f a
liftYoneda :: f a -> Yoneda f a
lowerYoneda :: Functor f => Yoneda f a -> f a
lowerM :: Monad f => Yoneda f a -> f a
instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g)
instance (Functor f, Ord (f a)) => Ord (Yoneda f a)
instance (Functor f, Eq (f a)) => Eq (Yoneda f a)
instance (Functor f, Read (f a)) => Read (Yoneda f a)
instance (Functor f, Show (f a)) => Show (Yoneda f a)
instance Distributive f => Distributive (Yoneda f)
instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f)
instance TraversableWithKey f => TraversableWithKey (Yoneda f)
instance Traversable1 f => Traversable1 (Yoneda f)
instance Traversable f => Traversable (Yoneda f)
instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f)
instance Foldable1 f => Foldable1 (Yoneda f)
instance FoldableWithKey f => FoldableWithKey (Yoneda f)
instance Foldable f => Foldable (Yoneda f)
instance ComonadTrans Yoneda
instance Comonad w => Comonad (Yoneda w)
instance Extend w => Extend (Yoneda w)
instance Representable f => Representable (Yoneda f)
instance (Functor f, Indexable f) => Indexable (Yoneda f)
instance (Functor f, Lookup f) => Lookup (Yoneda f)
instance MonadPlus f => MonadPlus (Yoneda f)
instance MonadFix f => MonadFix (Yoneda f)
instance MonadTrans Yoneda
instance Monad m => Monad (Yoneda m)
instance Bind m => Bind (Yoneda m)
instance Plus f => Plus (Yoneda f)
instance Alt f => Alt (Yoneda f)
instance Alternative f => Alternative (Yoneda f)
instance ZipWithKey f => ZipWithKey (Yoneda f)
instance Zip f => Zip (Yoneda f)
instance Applicative f => Applicative (Yoneda f)
instance Apply f => Apply (Yoneda f)
instance Keyed f => Keyed (Yoneda f)
instance Functor (Yoneda f)


module Data.Functor.Yoneda
newtype Yoneda f a
Yoneda :: (forall b. (a -> b) -> f b) -> Yoneda f a
runYoneda :: Yoneda f a -> forall b. (a -> b) -> f b
liftYoneda :: Functor f => f a -> Yoneda f a
lowerYoneda :: Yoneda f a -> f a
maxF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a
minF :: (Functor f, Ord (f a)) => Yoneda f a -> Yoneda f a -> Yoneda f a
maxM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a
minM :: (Monad m, Ord (m a)) => Yoneda m a -> Yoneda m a -> Yoneda m a
instance ComonadTrans Yoneda
instance Comonad w => Comonad (Yoneda w)
instance Extend w => Extend (Yoneda w)
instance (Functor f, MonadFree f m) => MonadFree f (Yoneda m)
instance MonadTrans Yoneda
instance MonadPlus m => MonadPlus (Yoneda m)
instance MonadFix m => MonadFix (Yoneda m)
instance Monad m => Monad (Yoneda m)
instance Bind m => Bind (Yoneda m)
instance Alternative f => Alternative (Yoneda f)
instance Plus f => Plus (Yoneda f)
instance Alt f => Alt (Yoneda f)
instance Ord (f a) => Ord (Yoneda f a)
instance Eq (f a) => Eq (Yoneda f a)
instance (Functor f, Read (f a)) => Read (Yoneda f a)
instance Show (f a) => Show (Yoneda f a)
instance Adjunction f g => Adjunction (Yoneda f) (Yoneda g)
instance Representable g => Representable (Yoneda g)
instance Lookup f => Lookup (Yoneda f)
instance Indexable f => Indexable (Yoneda f)
instance Distributive f => Distributive (Yoneda f)
instance TraversableWithKey1 f => TraversableWithKey1 (Yoneda f)
instance Traversable1 f => Traversable1 (Yoneda f)
instance TraversableWithKey f => TraversableWithKey (Yoneda f)
instance Traversable f => Traversable (Yoneda f)
instance FoldableWithKey1 f => FoldableWithKey1 (Yoneda f)
instance FoldableWithKey f => FoldableWithKey (Yoneda f)
instance Foldable1 f => Foldable1 (Yoneda f)
instance Foldable f => Foldable (Yoneda f)
instance ZipWithKey f => ZipWithKey (Yoneda f)
instance Zip f => Zip (Yoneda f)
instance Applicative f => Applicative (Yoneda f)
instance Apply f => Apply (Yoneda f)
instance Keyed f => Keyed (Yoneda f)
instance Functor (Yoneda f)


module Data.Functor.KanExtension
newtype Ran g h a
Ran :: (forall b. (a -> g b) -> h b) -> Ran g h a
runRan :: Ran g h a -> forall b. (a -> g b) -> h b

-- | <a>toRan</a> and <a>fromRan</a> witness a higher kinded adjunction.
--   from <tt>(`'Compose'` g)</tt> to <tt><a>Ran</a> g</tt>
toRan :: (Composition compose, Functor k) => (forall a. compose k g a -> h a) -> k b -> Ran g h b
fromRan :: Composition compose => (forall a. k a -> Ran g h a) -> compose k g b -> h b
composeRan :: Composition compose => Ran f (Ran g h) a -> Ran (compose f g) h a
decomposeRan :: (Composition compose, Functor f) => Ran (compose f g) h a -> Ran f (Ran g h) a
adjointToRan :: Adjunction f g => f a -> Ran g Identity a
ranToAdjoint :: Adjunction f g => Ran g Identity a -> f a
ranToComposedAdjoint :: (Composition compose, Adjunction f g) => Ran g h a -> compose h f a
composedAdjointToRan :: (Composition compose, Adjunction f g, Functor h) => compose h f a -> Ran g h a
data Lan g h a
Lan :: (g b -> a) -> h b -> Lan g h a
toLan :: (Composition compose, Functor f) => (forall a. h a -> compose f g a) -> Lan g h b -> f b
fromLan :: Composition compose => (forall a. Lan g h a -> f a) -> h b -> compose f g b
adjointToLan :: Adjunction f g => g a -> Lan f Identity a
lanToAdjoint :: Adjunction f g => Lan f Identity a -> g a

-- | <a>lanToComposedAdjoint</a> and <a>composedAdjointToLan</a> witness
--   the natural isomorphism between <tt>Lan f h</tt> and <tt>Compose h
--   g</tt> given <tt>f -| g</tt>
lanToComposedAdjoint :: (Composition compose, Functor h, Adjunction f g) => Lan f h a -> compose h g a
composedAdjointToLan :: Composition compose => Adjunction f g => compose h g a -> Lan f h a

-- | <a>composeLan</a> and <a>decomposeLan</a> witness the natural
--   isomorphism from <tt>Lan f (Lan g h)</tt> and <tt>Lan (f <tt>o</tt> g)
--   h</tt>
composeLan :: (Composition compose, Functor f) => Lan f (Lan g h) a -> Lan (compose f g) h a
decomposeLan :: Composition compose => Lan (compose f g) h a -> Lan f (Lan g h) a
instance Functor (Lan f g)
instance Functor (Ran g h)


-- | Free Monads for Less
--   
--   http:<i></i>comonad.com<i>reader</i>2011<i>free-monads-for-less-2</i>
module Control.Monad.Free.Church
newtype F f a
F :: (forall r. (a -> r) -> (f r -> r) -> r) -> F f a
runF :: F f a -> forall r. (a -> r) -> (f r -> r) -> r
improve :: Functor f => (forall m. MonadFree f m => m a) -> Free f a
fromF :: MonadFree f m => F f a -> m a
toF :: Functor f => Free f a -> F f a
liftF :: Functor f => f a -> F f a
retract :: Monad m => F m a -> m a
instance MonadCont m => MonadCont (F m)
instance MonadWriter w m => MonadWriter w (F m)
instance MonadReader e m => MonadReader e (F m)
instance MonadState s m => MonadState s (F m)
instance Functor f => MonadFree f (F f)
instance MonadTrans F
instance MonadPlus f => MonadPlus (F f)
instance Monad (F f)
instance Alternative f => Alternative (F f)
instance Applicative (F f)
instance Functor (F f)
instance MonadSpec (F f)


module Control.Monad.Codensity
newtype Codensity m a
Codensity :: (forall b. (a -> m b) -> m b) -> Codensity m a
runCodensity :: Codensity m a -> forall b. (a -> m b) -> m b
lowerCodensity :: Monad m => Codensity m a -> m a
codensityToAdjunction :: Adjunction f g => Codensity g a -> g (f a)
adjunctionToCodensity :: Adjunction f g => g (f a) -> Codensity g a

-- | Right associate all binds in a computation that generates a free monad
--   This can improve the asymptotic efficiency of the result, while
--   preserving semantics.
improve :: Functor f => (forall m. MonadFree f m => m a) -> Free f a
instance MonadReader r m => MonadState r (Codensity m)
instance (Functor f, MonadFree f m) => MonadFree f (Codensity m)
instance MonadPlus v => MonadPlus (Codensity v)
instance Alternative v => Alternative (Codensity v)
instance MonadTrans Codensity
instance MonadIO m => MonadIO (Codensity m)
instance Monad (Codensity f)
instance Applicative (Codensity f)
instance Apply (Codensity f)
instance Functor (Codensity k)
instance MonadSpec (Codensity m)


-- | Monads from Comonads
--   
--   http:<i></i>comonad.com<i>reader</i>2011<i>monads-from-comonads</i>
module Control.Monad.Co
type Co w = CoT w Identity
co :: Functor w => (forall r. w (a -> r) -> r) -> Co w a
runCo :: Functor w => Co w a -> w (a -> r) -> r
newtype CoT w m a
CoT :: (forall r. w (a -> m r) -> m r) -> CoT w m a
runCoT :: CoT w m a -> forall r. w (a -> m r) -> m r
liftCoT0 :: Comonad w => (forall a. w a -> s) -> CoT w m s
lowerCoT0 :: (Functor w, Monad m) => CoT w m s -> w a -> m s
lowerCo0 :: Functor w => Co w s -> w a -> s
liftCoT1 :: (forall a. w a -> a) -> CoT w m ()
lowerCoT1 :: (Functor w, Monad m) => CoT w m () -> w a -> m a
lowerCo1 :: Functor w => Co w () -> w a -> a
posW :: (ComonadStore s w, Monad m) => CoT w m s
peekW :: (ComonadStore s w, Monad m) => s -> CoT w m ()
peeksW :: (ComonadStore s w, Monad m) => (s -> s) -> CoT w m ()
askW :: (ComonadEnv e w, Monad m) => CoT w m e
asksW :: (ComonadEnv e w, Monad m) => (e -> a) -> CoT w m a
traceW :: (ComonadTraced e w, Monad m) => e -> CoT w m ()
instance (Comonad w, MonadError e m) => MonadError e (CoT w m)
instance (Comonad w, MonadWriter e m) => MonadWriter e (CoT w m)
instance (Comonad w, MonadState s m) => MonadState s (CoT w m)
instance (Comonad w, MonadReader e m) => MonadReader e (CoT w m)
instance (Comonad w, MonadIO m) => MonadIO (CoT w m)
instance Comonad w => MonadTrans (CoT w)
instance Comonad w => Monad (CoT w m)
instance Comonad w => Applicative (CoT w m)
instance Extend w => Bind (CoT w m)
instance Extend w => Apply (CoT w m)
instance Functor w => Functor (CoT w m)
instance Comonad w => MonadSpec (CoT w m)


-- | The density comonad for a functor. aka the comonad generated by a
--   functor The ''density'' term dates back to Dubuc''s 1974 thesis. The
--   term ''monad genererated by a functor'' dates back to 1972 in
--   Street''s ''Formal Theory of Monads''.
module Control.Comonad.Density
data Density k a
Density :: (k b -> a) -> k b -> Density k a

-- | The natural isomorphism between a comonad w and the comonad generated
--   by w (forwards).
liftDensity :: Comonad w => w a -> Density w a
densityToAdjunction :: Adjunction f g => Density f a -> f (g a)
adjunctionToDensity :: Adjunction f g => f (g a) -> Density f a
instance ComonadTrans Density
instance Comonad (Density f)
instance Extend (Density f)
instance Functor (Density f)