Portability  MPTCs, fundeps 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Safe Haskell  None 
The cofree comonad transformer
 newtype CofreeT f w a = CofreeT {
 runCofreeT :: w (CofreeF f a (CofreeT f w a))
 data CofreeF f a b = a :< (f b)
 class (Functor f, Comonad w) => ComonadCofree f w  w > f where
 unwrap :: w a > f (w a)
 headF :: CofreeF f a b > a
 tailF :: CofreeF f a b > f b
 coiterT :: (Functor f, Comonad w) => (w a > f (w a)) > w a > CofreeT f w a
Documentation
This is a cofree comonad of some functor f
, with a comonad w
threaded through it at each level.
CofreeT  

(Functor f, Comonad w) => ComonadCofree f (CofreeT f w)  
Functor f => ComonadTrans (CofreeT f)  
(Functor f, Functor w) => Functor (CofreeT f w)  
(Typeable1 f, Typeable1 w) => Typeable1 (CofreeT f w)  
(Foldable f, Foldable w) => Foldable (CofreeT f w)  
(Traversable f, Traversable w) => Traversable (CofreeT f w)  
(Functor f, Comonad w) => Comonad (CofreeT f w)  
Eq (w (CofreeF f a (CofreeT f w a))) => Eq (CofreeT f w a)  
(Typeable1 f, Typeable1 w, Typeable a, Data (w (CofreeF f a (CofreeT f w a))), Data a) => Data (CofreeT f w a)  
Ord (w (CofreeF f a (CofreeT f w a))) => Ord (CofreeT f w a)  
Read (w (CofreeF f a (CofreeT f w a))) => Read (CofreeT f w a)  
Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a) 
This is the base functor of the cofree comonad transformer.
a :< (f b) 
Typeable1 f => Typeable2 (CofreeF f)  
Traversable f => Bitraversable (CofreeF f)  
Functor f => Bifunctor (CofreeF f)  
Foldable f => Bifoldable (CofreeF f)  
Functor f => Functor (CofreeF f a)  
Foldable f => Foldable (CofreeF f a)  
Traversable f => Traversable (CofreeF f a)  
(Eq a, Eq (f b)) => Eq (CofreeF f a b)  
(Typeable1 f, Typeable a, Typeable b, Data a, Data (f b), Data b) => Data (CofreeF f a b)  
(Ord a, Ord (f b)) => Ord (CofreeF f a b)  
(Read a, Read (f b)) => Read (CofreeF f a b)  
(Show a, Show (f b)) => Show (CofreeF f a b) 
class (Functor f, Comonad w) => ComonadCofree f w  w > f whereSource
Allows you to peel a layer off a cofree comonad.
ComonadCofree f w => ComonadCofree f (IdentityT w)  
Functor f => ComonadCofree f (Cofree f)  
(ComonadCofree f w, Semigroup m, Monoid m) => ComonadCofree f (TracedT m w)  
ComonadCofree f w => ComonadCofree f (StoreT s w)  
ComonadCofree f w => ComonadCofree f (EnvT e w)  
(Functor f, Comonad w) => ComonadCofree f (CofreeT f w) 