Safe Haskell  Safe 

Language  Haskell2010 
Functor helpers
Synopsis
 transverse :: (Recursive s, Corecursive t, Functor f) => (forall a. Base s (f a) > f (Base t a)) > s > f t
 cataA :: Recursive t => (Base t (f a) > f a) > t > f a
 zygoHistoPrepro :: (Corecursive t, Recursive t) => (Base t b > b) > (forall c. Base t c > Base t c) > (Base t (EnvT b (Cofree (Base t)) a) > a) > t > a
 coelgot :: Functor f => ((a, f b) > b) > (a > f a) > a > b
 elgot :: Functor f => (f a > a) > (b > Either a (f b)) > b > a
 mhisto :: (forall y. (y > c) > (y > f y) > f y > c) > Fix f > c
 mcata :: (forall y. (y > c) > f y > c) > Fix f > c
 gchrono :: (Functor f, Functor w, Functor m, Comonad w, Monad m) => (forall c. f (w c) > w (f c)) > (forall c. m (f c) > f (m c)) > (f (CofreeT f w b) > b) > (a > f (FreeT f m a)) > a > b
 chrono :: Functor f => (f (Cofree f b) > b) > (a > f (Free f a)) > a > b
 distGHisto :: (Functor f, Functor h) => (forall b. f (h b) > h (f b)) > f (CofreeT f h a) > CofreeT f h (f a)
 distHisto :: Functor f => f (Cofree f a) > Cofree f (f a)
 ghisto :: (Recursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (CofreeT (Base t) w a) > a) > t > a
 histo :: Recursive t => (Base t (Cofree (Base t) a) > a) > t > a
 distGApoT :: (Functor f, Functor m) => (b > f b) > (forall c. m (f c) > f (m c)) > ExceptT b m (f a) > f (ExceptT b m a)
 distGApo :: Functor f => (b > f b) > Either b (f a) > f (Either b a)
 distApo :: Recursive t => Either t (Base t a) > Base t (Either t a)
 gapo :: Corecursive t => (b > Base t b) > (a > Base t (Either b a)) > a > t
 distZygoT :: (Functor f, Comonad w) => (f b > b) > (forall c. f (w c) > w (f c)) > f (EnvT b w a) > EnvT b w (f a)
 gzygo :: (Recursive t, Comonad w) => (Base t b > b) > (forall c. Base t (w c) > w (Base t c)) > (Base t (EnvT b w a) > a) > t > a
 distZygo :: Functor f => (f b > b) > f (b, a) > (b, f a)
 zygo :: Recursive t => (Base t b > b) > (Base t (b, a) > a) > t > a
 hoistNu :: (forall a. f a > g a) > Nu f > Nu g
 hoistMu :: (forall a. f a > g a) > Mu f > Mu g
 refix :: (Recursive s, Corecursive t, Base s ~ Base t) => s > t
 hoist :: (Recursive s, Corecursive t) => (forall a. Base s a > Base t a) > s > t
 unfix :: Fix f > f (Fix f)
 distGFutu :: (Functor f, Functor h) => (forall b. h (f b) > f (h b)) > FreeT f h (f a) > f (FreeT f h a)
 distFutu :: Functor f => Free f (f a) > f (Free f a)
 gfutu :: (Corecursive t, Functor m, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (a > Base t (FreeT (Base t) m a)) > a > t
 futu :: Corecursive t => (a > Base t (Free (Base t) a)) > a > t
 grefold :: (Comonad w, Functor f, Monad m) => (forall c. f (w c) > w (f c)) > (forall d. m (f d) > f (m d)) > (f (w b) > b) > (a > f (m a)) > a > b
 ghylo :: (Comonad w, Functor f, Monad m) => (forall c. f (w c) > w (f c)) > (forall d. m (f d) > f (m d)) > (f (w b) > b) > (a > f (m a)) > a > b
 distAna :: Functor f => Identity (f a) > f (Identity a)
 gunfold :: (Corecursive t, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (a > Base t (m a)) > a > t
 gana :: (Corecursive t, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (a > Base t (m a)) > a > t
 distCata :: Functor f => f (Identity a) > Identity (f a)
 gfold :: (Recursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (w a) > a) > t > a
 gcata :: (Recursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (w a) > a) > t > a
 refold :: Functor f => (f b > b) > (a > f a) > a > b
 unfold :: Corecursive t => (a > Base t a) > a > t
 fold :: Recursive t => (Base t a > a) > t > a
 hylo :: Functor f => (f b > b) > (a > f a) > a > b
 distParaT :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > Base t (EnvT t w a) > EnvT t w (Base t a)
 distPara :: Corecursive t => Base t (t, a) > (t, Base t a)
 type family Base t :: Type > Type
 class Functor (Base t) => Recursive t where
 project :: t > Base t t
 cata :: (Base t a > a) > t > a
 para :: (Base t (t, a) > a) > t > a
 gpara :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (EnvT t w a) > a) > t > a
 prepro :: Corecursive t => (forall b. Base t b > Base t b) > (Base t a > a) > t > a
 gprepro :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (forall c. Base t c > Base t c) > (Base t (w a) > a) > t > a
 class Functor (Base t) => Corecursive t where
 embed :: Base t t > t
 ana :: (a > Base t a) > a > t
 apo :: (a > Base t (Either t a)) > a > t
 postpro :: Recursive t => (forall b. Base t b > Base t b) > (a > Base t a) > a > t
 gpostpro :: (Recursive t, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (forall c. Base t c > Base t c) > (a > Base t (m a)) > a > t
 newtype Fix (f :: Type > Type) = Fix (f (Fix f))
 newtype Mu (f :: Type > Type) = Mu (forall a. (f a > a) > a)
 data Nu (f :: Type > Type) where
Documentation
transverse :: (Recursive s, Corecursive t, Functor f) => (forall a. Base s (f a) > f (Base t a)) > s > f t #
An effectful version of hoist
.
Properties:
transverse
sequenceA
=pure
Examples:
The weird type of first argument allows user to decide an order of sequencing:
>>>
transverse (\x > print (void x) *> sequence x) "foo" :: IO String
Cons 'f' () Cons 'o' () Cons 'o' () Nil "foo"
>>>
transverse (\x > sequence x <* print (void x)) "foo" :: IO String
Nil Cons 'o' () Cons 'o' () Cons 'f' () "foo"
cataA :: Recursive t => (Base t (f a) > f a) > t > f a #
Effectful fold.
This is a type specialisation of cata
.
An example terminating a recursion immediately:
>>>
cataA (\alg > case alg of { Nil > pure (); Cons a _ > Const [a] }) "hello"
Const "h"
zygoHistoPrepro :: (Corecursive t, Recursive t) => (Base t b > b) > (forall c. Base t c > Base t c) > (Base t (EnvT b (Cofree (Base t)) a) > a) > t > a #
Zygohistomorphic prepromorphisms:
A corrected and modernized version of http://www.haskell.org/haskellwiki/Zygohistomorphic_prepromorphisms
coelgot :: Functor f => ((a, f b) > b) > (a > f a) > a > b #
Elgot coalgebras: http://comonad.com/reader/2008/elgotcoalgebras/
mhisto :: (forall y. (y > c) > (y > f y) > f y > c) > Fix f > c #
Mendlerstyle courseofvalue iteration
gchrono :: (Functor f, Functor w, Functor m, Comonad w, Monad m) => (forall c. f (w c) > w (f c)) > (forall c. m (f c) > f (m c)) > (f (CofreeT f w b) > b) > (a > f (FreeT f m a)) > a > b #
distGHisto :: (Functor f, Functor h) => (forall b. f (h b) > h (f b)) > f (CofreeT f h a) > CofreeT f h (f a) #
ghisto :: (Recursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (CofreeT (Base t) w a) > a) > t > a #
distGApoT :: (Functor f, Functor m) => (b > f b) > (forall c. m (f c) > f (m c)) > ExceptT b m (f a) > f (ExceptT b m a) #
distZygoT :: (Functor f, Comonad w) => (f b > b) > (forall c. f (w c) > w (f c)) > f (EnvT b w a) > EnvT b w (f a) #
gzygo :: (Recursive t, Comonad w) => (Base t b > b) > (forall c. Base t (w c) > w (Base t c)) > (Base t (EnvT b w a) > a) > t > a #
distGFutu :: (Functor f, Functor h) => (forall b. h (f b) > f (h b)) > FreeT f h (f a) > f (FreeT f h a) #
gfutu :: (Corecursive t, Functor m, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (a > Base t (FreeT (Base t) m a)) > a > t #
grefold :: (Comonad w, Functor f, Monad m) => (forall c. f (w c) > w (f c)) > (forall d. m (f d) > f (m d)) > (f (w b) > b) > (a > f (m a)) > a > b #
A generalized hylomorphism
ghylo :: (Comonad w, Functor f, Monad m) => (forall c. f (w c) > w (f c)) > (forall d. m (f d) > f (m d)) > (f (w b) > b) > (a > f (m a)) > a > b #
A generalized hylomorphism
:: (Corecursive t, Monad m)  
=> (forall b. m (Base t b) > Base t (m b))  a distributive law 
> (a > Base t (m a))  a (Base t)mcoalgebra 
> a  seed 
> t 
A generalized anamorphism
:: (Corecursive t, Monad m)  
=> (forall b. m (Base t b) > Base t (m b))  a distributive law 
> (a > Base t (m a))  a (Base t)mcoalgebra 
> a  seed 
> t 
A generalized anamorphism
:: (Recursive t, Comonad w)  
=> (forall b. Base t (w b) > w (Base t b))  a distributive law 
> (Base t (w a) > a)  a (Base t)walgebra 
> t  fixed point 
> a 
A generalized catamorphism
:: (Recursive t, Comonad w)  
=> (forall b. Base t (w b) > w (Base t b))  a distributive law 
> (Base t (w a) > a)  a (Base t)walgebra 
> t  fixed point 
> a 
A generalized catamorphism
unfold :: Corecursive t => (a > Base t a) > a > t #
distParaT :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > Base t (EnvT t w a) > EnvT t w (Base t a) #
distPara :: Corecursive t => Base t (t, a) > (t, Base t a) #
type family Base t :: Type > Type #
Instances
type Base Natural  
Defined in Data.Functor.Foldable  
type Base [a]  
Defined in Data.Functor.Foldable  
type Base (Maybe a)  Example boring stub for nonrecursive data types 
type Base (NonEmpty a)  
Defined in Data.Functor.Foldable  
type Base (Fix f)  
Defined in Data.Functor.Foldable  
type Base (Mu f)  
Defined in Data.Functor.Foldable  
type Base (Nu f)  
Defined in Data.Functor.Foldable  
type Base (Either a b)  Example boring stub for nonrecursive data types 
type Base (Cofree f a)  Cofree comonads are Recursive/Corecursive 
Defined in Data.Functor.Foldable  
type Base (F f a)  Church encoded free monads are Recursive/Corecursive, in the same way that

Defined in Data.Functor.Foldable  
type Base (Free f a)  Free monads are Recursive/Corecursive 
Defined in Data.Functor.Foldable  
type Base (FreeT f m a)  Free transformations of monads are Recursive/Corecursive 
Defined in Data.Functor.Foldable  
type Base (CofreeT f w a)  Cofree tranformations of comonads are Recursive/Corecusive 
Defined in Data.Functor.Foldable 
class Functor (Base t) => Recursive t where #
:: (Base t a > a)  a (Base t)algebra 
> t  fixed point 
> a  result 
para :: (Base t (t, a) > a) > t > a #
gpara :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (Base t (EnvT t w a) > a) > t > a #
prepro :: Corecursive t => (forall b. Base t b > Base t b) > (Base t a > a) > t > a #
Fokkinga's prepromorphism
gprepro :: (Corecursive t, Comonad w) => (forall b. Base t (w b) > w (Base t b)) > (forall c. Base t c > Base t c) > (Base t (w a) > a) > t > a #
Instances
Recursive Natural  
Defined in Data.Functor.Foldable project :: Natural > Base Natural Natural # cata :: (Base Natural a > a) > Natural > a # para :: (Base Natural (Natural, a) > a) > Natural > a # gpara :: (Corecursive Natural, Comonad w) => (forall b. Base Natural (w b) > w (Base Natural b)) > (Base Natural (EnvT Natural w a) > a) > Natural > a # prepro :: Corecursive Natural => (forall b. Base Natural b > Base Natural b) > (Base Natural a > a) > Natural > a # gprepro :: (Corecursive Natural, Comonad w) => (forall b. Base Natural (w b) > w (Base Natural b)) > (forall c. Base Natural c > Base Natural c) > (Base Natural (w a) > a) > Natural > a #  
Recursive [a]  
Defined in Data.Functor.Foldable project :: [a] > Base [a] [a] # cata :: (Base [a] a0 > a0) > [a] > a0 # para :: (Base [a] ([a], a0) > a0) > [a] > a0 # gpara :: (Corecursive [a], Comonad w) => (forall b. Base [a] (w b) > w (Base [a] b)) > (Base [a] (EnvT [a] w a0) > a0) > [a] > a0 # prepro :: Corecursive [a] => (forall b. Base [a] b > Base [a] b) > (Base [a] a0 > a0) > [a] > a0 # gprepro :: (Corecursive [a], Comonad w) => (forall b. Base [a] (w b) > w (Base [a] b)) > (forall c. Base [a] c > Base [a] c) > (Base [a] (w a0) > a0) > [a] > a0 #  
Recursive (Maybe a)  
Defined in Data.Functor.Foldable project :: Maybe a > Base (Maybe a) (Maybe a) # cata :: (Base (Maybe a) a0 > a0) > Maybe a > a0 # para :: (Base (Maybe a) (Maybe a, a0) > a0) > Maybe a > a0 # gpara :: (Corecursive (Maybe a), Comonad w) => (forall b. Base (Maybe a) (w b) > w (Base (Maybe a) b)) > (Base (Maybe a) (EnvT (Maybe a) w a0) > a0) > Maybe a > a0 # prepro :: Corecursive (Maybe a) => (forall b. Base (Maybe a) b > Base (Maybe a) b) > (Base (Maybe a) a0 > a0) > Maybe a > a0 # gprepro :: (Corecursive (Maybe a), Comonad w) => (forall b. Base (Maybe a) (w b) > w (Base (Maybe a) b)) > (forall c. Base (Maybe a) c > Base (Maybe a) c) > (Base (Maybe a) (w a0) > a0) > Maybe a > a0 #  
Recursive (NonEmpty a)  
Defined in Data.Functor.Foldable project :: NonEmpty a > Base (NonEmpty a) (NonEmpty a) # cata :: (Base (NonEmpty a) a0 > a0) > NonEmpty a > a0 # para :: (Base (NonEmpty a) (NonEmpty a, a0) > a0) > NonEmpty a > a0 # gpara :: (Corecursive (NonEmpty a), Comonad w) => (forall b. Base (NonEmpty a) (w b) > w (Base (NonEmpty a) b)) > (Base (NonEmpty a) (EnvT (NonEmpty a) w a0) > a0) > NonEmpty a > a0 # prepro :: Corecursive (NonEmpty a) => (forall b. Base (NonEmpty a) b > Base (NonEmpty a) b) > (Base (NonEmpty a) a0 > a0) > NonEmpty a > a0 # gprepro :: (Corecursive (NonEmpty a), Comonad w) => (forall b. Base (NonEmpty a) (w b) > w (Base (NonEmpty a) b)) > (forall c. Base (NonEmpty a) c > Base (NonEmpty a) c) > (Base (NonEmpty a) (w a0) > a0) > NonEmpty a > a0 #  
Functor f => Recursive (Fix f)  
Defined in Data.Functor.Foldable project :: Fix f > Base (Fix f) (Fix f) # cata :: (Base (Fix f) a > a) > Fix f > a # para :: (Base (Fix f) (Fix f, a) > a) > Fix f > a # gpara :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) > w (Base (Fix f) b)) > (Base (Fix f) (EnvT (Fix f) w a) > a) > Fix f > a # prepro :: Corecursive (Fix f) => (forall b. Base (Fix f) b > Base (Fix f) b) > (Base (Fix f) a > a) > Fix f > a # gprepro :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) > w (Base (Fix f) b)) > (forall c. Base (Fix f) c > Base (Fix f) c) > (Base (Fix f) (w a) > a) > Fix f > a #  
Functor f => Recursive (Mu f)  
Defined in Data.Functor.Foldable project :: Mu f > Base (Mu f) (Mu f) # cata :: (Base (Mu f) a > a) > Mu f > a # para :: (Base (Mu f) (Mu f, a) > a) > Mu f > a # gpara :: (Corecursive (Mu f), Comonad w) => (forall b. Base (Mu f) (w b) > w (Base (Mu f) b)) > (Base (Mu f) (EnvT (Mu f) w a) > a) > Mu f > a # prepro :: Corecursive (Mu f) => (forall b. Base (Mu f) b > Base (Mu f) b) > (Base (Mu f) a > a) > Mu f > a # gprepro :: (Corecursive (Mu f), Comonad w) => (forall b. Base (Mu f) (w b) > w (Base (Mu f) b)) > (forall c. Base (Mu f) c > Base (Mu f) c) > (Base (Mu f) (w a) > a) > Mu f > a #  
Functor f => Recursive (Nu f)  
Defined in Data.Functor.Foldable project :: Nu f > Base (Nu f) (Nu f) # cata :: (Base (Nu f) a > a) > Nu f > a # para :: (Base (Nu f) (Nu f, a) > a) > Nu f > a # gpara :: (Corecursive (Nu f), Comonad w) => (forall b. Base (Nu f) (w b) > w (Base (Nu f) b)) > (Base (Nu f) (EnvT (Nu f) w a) > a) > Nu f > a # prepro :: Corecursive (Nu f) => (forall b. Base (Nu f) b > Base (Nu f) b) > (Base (Nu f) a > a) > Nu f > a # gprepro :: (Corecursive (Nu f), Comonad w) => (forall b. Base (Nu f) (w b) > w (Base (Nu f) b)) > (forall c. Base (Nu f) c > Base (Nu f) c) > (Base (Nu f) (w a) > a) > Nu f > a #  
Recursive (Either a b)  
Defined in Data.Functor.Foldable project :: Either a b > Base (Either a b) (Either a b) # cata :: (Base (Either a b) a0 > a0) > Either a b > a0 # para :: (Base (Either a b) (Either a b, a0) > a0) > Either a b > a0 # gpara :: (Corecursive (Either a b), Comonad w) => (forall b0. Base (Either a b) (w b0) > w (Base (Either a b) b0)) > (Base (Either a b) (EnvT (Either a b) w a0) > a0) > Either a b > a0 # prepro :: Corecursive (Either a b) => (forall b0. Base (Either a b) b0 > Base (Either a b) b0) > (Base (Either a b) a0 > a0) > Either a b > a0 # gprepro :: (Corecursive (Either a b), Comonad w) => (forall b0. Base (Either a b) (w b0) > w (Base (Either a b) b0)) > (forall c. Base (Either a b) c > Base (Either a b) c) > (Base (Either a b) (w a0) > a0) > Either a b > a0 #  
Functor f => Recursive (Cofree f a)  
Defined in Data.Functor.Foldable project :: Cofree f a > Base (Cofree f a) (Cofree f a) # cata :: (Base (Cofree f a) a0 > a0) > Cofree f a > a0 # para :: (Base (Cofree f a) (Cofree f a, a0) > a0) > Cofree f a > a0 # gpara :: (Corecursive (Cofree f a), Comonad w) => (forall b. Base (Cofree f a) (w b) > w (Base (Cofree f a) b)) > (Base (Cofree f a) (EnvT (Cofree f a) w a0) > a0) > Cofree f a > a0 # prepro :: Corecursive (Cofree f a) => (forall b. Base (Cofree f a) b > Base (Cofree f a) b) > (Base (Cofree f a) a0 > a0) > Cofree f a > a0 # gprepro :: (Corecursive (Cofree f a), Comonad w) => (forall b. Base (Cofree f a) (w b) > w (Base (Cofree f a) b)) > (forall c. Base (Cofree f a) c > Base (Cofree f a) c) > (Base (Cofree f a) (w a0) > a0) > Cofree f a > a0 #  
Functor f => Recursive (F f a)  
Defined in Data.Functor.Foldable project :: F f a > Base (F f a) (F f a) # cata :: (Base (F f a) a0 > a0) > F f a > a0 # para :: (Base (F f a) (F f a, a0) > a0) > F f a > a0 # gpara :: (Corecursive (F f a), Comonad w) => (forall b. Base (F f a) (w b) > w (Base (F f a) b)) > (Base (F f a) (EnvT (F f a) w a0) > a0) > F f a > a0 # prepro :: Corecursive (F f a) => (forall b. Base (F f a) b > Base (F f a) b) > (Base (F f a) a0 > a0) > F f a > a0 # gprepro :: (Corecursive (F f a), Comonad w) => (forall b. Base (F f a) (w b) > w (Base (F f a) b)) > (forall c. Base (F f a) c > Base (F f a) c) > (Base (F f a) (w a0) > a0) > F f a > a0 #  
Functor f => Recursive (Free f a)  
Defined in Data.Functor.Foldable project :: Free f a > Base (Free f a) (Free f a) # cata :: (Base (Free f a) a0 > a0) > Free f a > a0 # para :: (Base (Free f a) (Free f a, a0) > a0) > Free f a > a0 # gpara :: (Corecursive (Free f a), Comonad w) => (forall b. Base (Free f a) (w b) > w (Base (Free f a) b)) > (Base (Free f a) (EnvT (Free f a) w a0) > a0) > Free f a > a0 # prepro :: Corecursive (Free f a) => (forall b. Base (Free f a) b > Base (Free f a) b) > (Base (Free f a) a0 > a0) > Free f a > a0 # gprepro :: (Corecursive (Free f a), Comonad w) => (forall b. Base (Free f a) (w b) > w (Base (Free f a) b)) > (forall c. Base (Free f a) c > Base (Free f a) c) > (Base (Free f a) (w a0) > a0) > Free f a > a0 #  
(Functor m, Functor f) => Recursive (FreeT f m a)  
Defined in Data.Functor.Foldable project :: FreeT f m a > Base (FreeT f m a) (FreeT f m a) # cata :: (Base (FreeT f m a) a0 > a0) > FreeT f m a > a0 # para :: (Base (FreeT f m a) (FreeT f m a, a0) > a0) > FreeT f m a > a0 # gpara :: (Corecursive (FreeT f m a), Comonad w) => (forall b. Base (FreeT f m a) (w b) > w (Base (FreeT f m a) b)) > (Base (FreeT f m a) (EnvT (FreeT f m a) w a0) > a0) > FreeT f m a > a0 # prepro :: Corecursive (FreeT f m a) => (forall b. Base (FreeT f m a) b > Base (FreeT f m a) b) > (Base (FreeT f m a) a0 > a0) > FreeT f m a > a0 # gprepro :: (Corecursive (FreeT f m a), Comonad w) => (forall b. Base (FreeT f m a) (w b) > w (Base (FreeT f m a) b)) > (forall c. Base (FreeT f m a) c > Base (FreeT f m a) c) > (Base (FreeT f m a) (w a0) > a0) > FreeT f m a > a0 #  
(Functor w, Functor f) => Recursive (CofreeT f w a)  
Defined in Data.Functor.Foldable project :: CofreeT f w a > Base (CofreeT f w a) (CofreeT f w a) # cata :: (Base (CofreeT f w a) a0 > a0) > CofreeT f w a > a0 # para :: (Base (CofreeT f w a) (CofreeT f w a, a0) > a0) > CofreeT f w a > a0 # gpara :: (Corecursive (CofreeT f w a), Comonad w0) => (forall b. Base (CofreeT f w a) (w0 b) > w0 (Base (CofreeT f w a) b)) > (Base (CofreeT f w a) (EnvT (CofreeT f w a) w0 a0) > a0) > CofreeT f w a > a0 # prepro :: Corecursive (CofreeT f w a) => (forall b. Base (CofreeT f w a) b > Base (CofreeT f w a) b) > (Base (CofreeT f w a) a0 > a0) > CofreeT f w a > a0 # gprepro :: (Corecursive (CofreeT f w a), Comonad w0) => (forall b. Base (CofreeT f w a) (w0 b) > w0 (Base (CofreeT f w a) b)) > (forall c. Base (CofreeT f w a) c > Base (CofreeT f w a) c) > (Base (CofreeT f w a) (w0 a0) > a0) > CofreeT f w a > a0 # 
class Functor (Base t) => Corecursive t where #
:: (a > Base t a)  a (Base t)coalgebra 
> a  seed 
> t  resulting fixed point 
apo :: (a > Base t (Either t a)) > a > t #
postpro :: Recursive t => (forall b. Base t b > Base t b) > (a > Base t a) > a > t #
Fokkinga's postpromorphism
gpostpro :: (Recursive t, Monad m) => (forall b. m (Base t b) > Base t (m b)) > (forall c. Base t c > Base t c) > (a > Base t (m a)) > a > t #
A generalized postpromorphism
Instances
Corecursive Natural  
Defined in Data.Functor.Foldable embed :: Base Natural Natural > Natural # ana :: (a > Base Natural a) > a > Natural # apo :: (a > Base Natural (Either Natural a)) > a > Natural # postpro :: Recursive Natural => (forall b. Base Natural b > Base Natural b) > (a > Base Natural a) > a > Natural # gpostpro :: (Recursive Natural, Monad m) => (forall b. m (Base Natural b) > Base Natural (m b)) > (forall c. Base Natural c > Base Natural c) > (a > Base Natural (m a)) > a > Natural #  
Corecursive [a]  
Defined in Data.Functor.Foldable embed :: Base [a] [a] > [a] # ana :: (a0 > Base [a] a0) > a0 > [a] # apo :: (a0 > Base [a] (Either [a] a0)) > a0 > [a] # postpro :: Recursive [a] => (forall b. Base [a] b > Base [a] b) > (a0 > Base [a] a0) > a0 > [a] # gpostpro :: (Recursive [a], Monad m) => (forall b. m (Base [a] b) > Base [a] (m b)) > (forall c. Base [a] c > Base [a] c) > (a0 > Base [a] (m a0)) > a0 > [a] #  
Corecursive (Maybe a)  
Defined in Data.Functor.Foldable embed :: Base (Maybe a) (Maybe a) > Maybe a # ana :: (a0 > Base (Maybe a) a0) > a0 > Maybe a # apo :: (a0 > Base (Maybe a) (Either (Maybe a) a0)) > a0 > Maybe a # postpro :: Recursive (Maybe a) => (forall b. Base (Maybe a) b > Base (Maybe a) b) > (a0 > Base (Maybe a) a0) > a0 > Maybe a # gpostpro :: (Recursive (Maybe a), Monad m) => (forall b. m (Base (Maybe a) b) > Base (Maybe a) (m b)) > (forall c. Base (Maybe a) c > Base (Maybe a) c) > (a0 > Base (Maybe a) (m a0)) > a0 > Maybe a #  
Corecursive (NonEmpty a)  
Defined in Data.Functor.Foldable embed :: Base (NonEmpty a) (NonEmpty a) > NonEmpty a # ana :: (a0 > Base (NonEmpty a) a0) > a0 > NonEmpty a # apo :: (a0 > Base (NonEmpty a) (Either (NonEmpty a) a0)) > a0 > NonEmpty a # postpro :: Recursive (NonEmpty a) => (forall b. Base (NonEmpty a) b > Base (NonEmpty a) b) > (a0 > Base (NonEmpty a) a0) > a0 > NonEmpty a # gpostpro :: (Recursive (NonEmpty a), Monad m) => (forall b. m (Base (NonEmpty a) b) > Base (NonEmpty a) (m b)) > (forall c. Base (NonEmpty a) c > Base (NonEmpty a) c) > (a0 > Base (NonEmpty a) (m a0)) > a0 > NonEmpty a #  
Functor f => Corecursive (Fix f)  
Defined in Data.Functor.Foldable embed :: Base (Fix f) (Fix f) > Fix f # ana :: (a > Base (Fix f) a) > a > Fix f # apo :: (a > Base (Fix f) (Either (Fix f) a)) > a > Fix f # postpro :: Recursive (Fix f) => (forall b. Base (Fix f) b > Base (Fix f) b) > (a > Base (Fix f) a) > a > Fix f # gpostpro :: (Recursive (Fix f), Monad m) => (forall b. m (Base (Fix f) b) > Base (Fix f) (m b)) > (forall c. Base (Fix f) c > Base (Fix f) c) > (a > Base (Fix f) (m a)) > a > Fix f #  
Functor f => Corecursive (Mu f)  
Defined in Data.Functor.Foldable embed :: Base (Mu f) (Mu f) > Mu f # ana :: (a > Base (Mu f) a) > a > Mu f # apo :: (a > Base (Mu f) (Either (Mu f) a)) > a > Mu f # postpro :: Recursive (Mu f) => (forall b. Base (Mu f) b > Base (Mu f) b) > (a > Base (Mu f) a) > a > Mu f # gpostpro :: (Recursive (Mu f), Monad m) => (forall b. m (Base (Mu f) b) > Base (Mu f) (m b)) > (forall c. Base (Mu f) c > Base (Mu f) c) > (a > Base (Mu f) (m a)) > a > Mu f #  
Functor f => Corecursive (Nu f)  
Defined in Data.Functor.Foldable embed :: Base (Nu f) (Nu f) > Nu f # ana :: (a > Base (Nu f) a) > a > Nu f # apo :: (a > Base (Nu f) (Either (Nu f) a)) > a > Nu f # postpro :: Recursive (Nu f) => (forall b. Base (Nu f) b > Base (Nu f) b) > (a > Base (Nu f) a) > a > Nu f # gpostpro :: (Recursive (Nu f), Monad m) => (forall b. m (Base (Nu f) b) > Base (Nu f) (m b)) > (forall c. Base (Nu f) c > Base (Nu f) c) > (a > Base (Nu f) (m a)) > a > Nu f #  
Corecursive (Either a b)  
Defined in Data.Functor.Foldable embed :: Base (Either a b) (Either a b) > Either a b # ana :: (a0 > Base (Either a b) a0) > a0 > Either a b # apo :: (a0 > Base (Either a b) (Either (Either a b) a0)) > a0 > Either a b # postpro :: Recursive (Either a b) => (forall b0. Base (Either a b) b0 > Base (Either a b) b0) > (a0 > Base (Either a b) a0) > a0 > Either a b # gpostpro :: (Recursive (Either a b), Monad m) => (forall b0. m (Base (Either a b) b0) > Base (Either a b) (m b0)) > (forall c. Base (Either a b) c > Base (Either a b) c) > (a0 > Base (Either a b) (m a0)) > a0 > Either a b #  
Functor f => Corecursive (Cofree f a)  
Defined in Data.Functor.Foldable embed :: Base (Cofree f a) (Cofree f a) > Cofree f a # ana :: (a0 > Base (Cofree f a) a0) > a0 > Cofree f a # apo :: (a0 > Base (Cofree f a) (Either (Cofree f a) a0)) > a0 > Cofree f a # postpro :: Recursive (Cofree f a) => (forall b. Base (Cofree f a) b > Base (Cofree f a) b) > (a0 > Base (Cofree f a) a0) > a0 > Cofree f a # gpostpro :: (Recursive (Cofree f a), Monad m) => (forall b. m (Base (Cofree f a) b) > Base (Cofree f a) (m b)) > (forall c. Base (Cofree f a) c > Base (Cofree f a) c) > (a0 > Base (Cofree f a) (m a0)) > a0 > Cofree f a #  
Functor f => Corecursive (F f a)  
Defined in Data.Functor.Foldable embed :: Base (F f a) (F f a) > F f a # ana :: (a0 > Base (F f a) a0) > a0 > F f a # apo :: (a0 > Base (F f a) (Either (F f a) a0)) > a0 > F f a # postpro :: Recursive (F f a) => (forall b. Base (F f a) b > Base (F f a) b) > (a0 > Base (F f a) a0) > a0 > F f a # gpostpro :: (Recursive (F f a), Monad m) => (forall b. m (Base (F f a) b) > Base (F f a) (m b)) > (forall c. Base (F f a) c > Base (F f a) c) > (a0 > Base (F f a) (m a0)) > a0 > F f a #  
Functor f => Corecursive (Free f a)  It may be better to work with the instance for 
Defined in Data.Functor.Foldable embed :: Base (Free f a) (Free f a) > Free f a # ana :: (a0 > Base (Free f a) a0) > a0 > Free f a # apo :: (a0 > Base (Free f a) (Either (Free f a) a0)) > a0 > Free f a # postpro :: Recursive (Free f a) => (forall b. Base (Free f a) b > Base (Free f a) b) > (a0 > Base (Free f a) a0) > a0 > Free f a # gpostpro :: (Recursive (Free f a), Monad m) => (forall b. m (Base (Free f a) b) > Base (Free f a) (m b)) > (forall c. Base (Free f a) c > Base (Free f a) c) > (a0 > Base (Free f a) (m a0)) > a0 > Free f a #  
(Functor m, Functor f) => Corecursive (FreeT f m a)  
Defined in Data.Functor.Foldable embed :: Base (FreeT f m a) (FreeT f m a) > FreeT f m a # ana :: (a0 > Base (FreeT f m a) a0) > a0 > FreeT f m a # apo :: (a0 > Base (FreeT f m a) (Either (FreeT f m a) a0)) > a0 > FreeT f m a # postpro :: Recursive (FreeT f m a) => (forall b. Base (FreeT f m a) b > Base (FreeT f m a) b) > (a0 > Base (FreeT f m a) a0) > a0 > FreeT f m a # gpostpro :: (Recursive (FreeT f m a), Monad m0) => (forall b. m0 (Base (FreeT f m a) b) > Base (FreeT f m a) (m0 b)) > (forall c. Base (FreeT f m a) c > Base (FreeT f m a) c) > (a0 > Base (FreeT f m a) (m0 a0)) > a0 > FreeT f m a #  
(Functor w, Functor f) => Corecursive (CofreeT f w a)  
Defined in Data.Functor.Foldable embed :: Base (CofreeT f w a) (CofreeT f w a) > CofreeT f w a # ana :: (a0 > Base (CofreeT f w a) a0) > a0 > CofreeT f w a # apo :: (a0 > Base (CofreeT f w a) (Either (CofreeT f w a) a0)) > a0 > CofreeT f w a # postpro :: Recursive (CofreeT f w a) => (forall b. Base (CofreeT f w a) b > Base (CofreeT f w a) b) > (a0 > Base (CofreeT f w a) a0) > a0 > CofreeT f w a # gpostpro :: (Recursive (CofreeT f w a), Monad m) => (forall b. m (Base (CofreeT f w a) b) > Base (CofreeT f w a) (m b)) > (forall c. Base (CofreeT f w a) c > Base (CofreeT f w a) c) > (a0 > Base (CofreeT f w a) (m a0)) > a0 > CofreeT f w a # 
newtype Fix (f :: Type > Type) #
Instances
Eq1 f => Eq (Fix f)  
(Typeable f, Data (f (Fix f))) => Data (Fix f)  
Defined in Data.Functor.Foldable gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Fix f > c (Fix f) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (Fix f) # dataTypeOf :: Fix f > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Fix f)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (Fix f)) # gmapT :: (forall b. Data b => b > b) > Fix f > Fix f # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Fix f > r # gmapQr :: (r' > r > r) > r > (forall d. Data d => d > r') > Fix f > r # gmapQ :: (forall d. Data d => d > u) > Fix f > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Fix f > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Fix f > m (Fix f) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Fix f > m (Fix f) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Fix f > m (Fix f) #  
Ord1 f => Ord (Fix f)  
Read1 f => Read (Fix f)  
Show1 f => Show (Fix f)  
Functor f => Recursive (Fix f)  
Defined in Data.Functor.Foldable project :: Fix f > Base (Fix f) (Fix f) # cata :: (Base (Fix f) a > a) > Fix f > a # para :: (Base (Fix f) (Fix f, a) > a) > Fix f > a # gpara :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) > w (Base (Fix f) b)) > (Base (Fix f) (EnvT (Fix f) w a) > a) > Fix f > a # prepro :: Corecursive (Fix f) => (forall b. Base (Fix f) b > Base (Fix f) b) > (Base (Fix f) a > a) > Fix f > a # gprepro :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) > w (Base (Fix f) b)) > (forall c. Base (Fix f) c > Base (Fix f) c) > (Base (Fix f) (w a) > a) > Fix f > a #  
Functor f => Corecursive (Fix f)  
Defined in Data.Functor.Foldable embed :: Base (Fix f) (Fix f) > Fix f # ana :: (a > Base (Fix f) a) > a > Fix f # apo :: (a > Base (Fix f) (Either (Fix f) a)) > a > Fix f # postpro :: Recursive (Fix f) => (forall b. Base (Fix f) b > Base (Fix f) b) > (a > Base (Fix f) a) > a > Fix f # gpostpro :: (Recursive (Fix f), Monad m) => (forall b. m (Base (Fix f) b) > Base (Fix f) (m b)) > (forall c. Base (Fix f) c > Base (Fix f) c) > (a > Base (Fix f) (m a)) > a > Fix f #  
type Base (Fix f)  
Defined in Data.Functor.Foldable 
newtype Mu (f :: Type > Type) #
Mu (forall a. (f a > a) > a) 
Instances
(Functor f, Eq1 f) => Eq (Mu f)  
(Functor f, Ord1 f) => Ord (Mu f)  
(Functor f, Read1 f) => Read (Mu f)  
(Functor f, Show1 f) => Show (Mu f)  
Functor f => Recursive (Mu f)  
Defined in Data.Functor.Foldable project :: Mu f > Base (Mu f) (Mu f) # cata :: (Base (Mu f) a > a) > Mu f > a # para :: (Base (Mu f) (Mu f, a) > a) > Mu f > a # gpara :: (Corecursive (Mu f), Comonad w) => (forall b. Base (Mu f) (w b) > w (Base (Mu f) b)) > (Base (Mu f) (EnvT (Mu f) w a) > a) > Mu f > a # prepro :: Corecursive (Mu f) => (forall b. Base (Mu f) b > Base (Mu f) b) > (Base (Mu f) a > a) > Mu f > a # gprepro :: (Corecursive (Mu f), Comonad w) => (forall b. Base (Mu f) (w b) > w (Base (Mu f) b)) > (forall c. Base (Mu f) c > Base (Mu f) c) > (Base (Mu f) (w a) > a) > Mu f > a #  
Functor f => Corecursive (Mu f)  
Defined in Data.Functor.Foldable embed :: Base (Mu f) (Mu f) > Mu f # ana :: (a > Base (Mu f) a) > a > Mu f # apo :: (a > Base (Mu f) (Either (Mu f) a)) > a > Mu f # postpro :: Recursive (Mu f) => (forall b. Base (Mu f) b > Base (Mu f) b) > (a > Base (Mu f) a) > a > Mu f # gpostpro :: (Recursive (Mu f), Monad m) => (forall b. m (Base (Mu f) b) > Base (Mu f) (m b)) > (forall c. Base (Mu f) c > Base (Mu f) c) > (a > Base (Mu f) (m a)) > a > Mu f #  
type Base (Mu f)  
Defined in Data.Functor.Foldable 
data Nu (f :: Type > Type) where #
Instances
(Functor f, Eq1 f) => Eq (Nu f)  
(Functor f, Ord1 f) => Ord (Nu f)  
(Functor f, Read1 f) => Read (Nu f)  
(Functor f, Show1 f) => Show (Nu f)  
Functor f => Recursive (Nu f)  
Defined in Data.Functor.Foldable project :: Nu f > Base (Nu f) (Nu f) # cata :: (Base (Nu f) a > a) > Nu f > a # para :: (Base (Nu f) (Nu f, a) > a) > Nu f > a # gpara :: (Corecursive (Nu f), Comonad w) => (forall b. Base (Nu f) (w b) > w (Base (Nu f) b)) > (Base (Nu f) (EnvT (Nu f) w a) > a) > Nu f > a # prepro :: Corecursive (Nu f) => (forall b. Base (Nu f) b > Base (Nu f) b) > (Base (Nu f) a > a) > Nu f > a # gprepro :: (Corecursive (Nu f), Comonad w) => (forall b. Base (Nu f) (w b) > w (Base (Nu f) b)) > (forall c. Base (Nu f) c > Base (Nu f) c) > (Base (Nu f) (w a) > a) > Nu f > a #  
Functor f => Corecursive (Nu f)  
Defined in Data.Functor.Foldable embed :: Base (Nu f) (Nu f) > Nu f # ana :: (a > Base (Nu f) a) > a > Nu f # apo :: (a > Base (Nu f) (Either (Nu f) a)) > a > Nu f # postpro :: Recursive (Nu f) => (forall b. Base (Nu f) b > Base (Nu f) b) > (a > Base (Nu f) a) > a > Nu f # gpostpro :: (Recursive (Nu f), Monad m) => (forall b. m (Base (Nu f) b) > Base (Nu f) (m b)) > (forall c. Base (Nu f) c > Base (Nu f) c) > (a > Base (Nu f) (m a)) > a > Nu f #  
type Base (Nu f)  
Defined in Data.Functor.Foldable 