Safe Haskell	None
Language	Haskell2010

Haskus.Utils.Functor

Contents

Simple API
Recursion schemes
Higher-order recursion schemes

Description

Functor and recursion schemes

Simple API is intended to be easier to understand (e.g. they don't use xxmorphism and xxxalgebra jargon but tree-traversal-like terms).

Synopsis

type BottomUpT a f = f a -> a
bottomUp :: Recursive t => (Base t a -> a) -> t -> a
type BottomUpOrigT t a f = f (t, a) -> a
bottomUpOrig :: Recursive t => (Base t (t, a) -> a) -> t -> a
type TopDownStopT a f = f a -> Either (f a) a
topDownStop :: (Recursive t, Corecursive t) => (Base t t -> Either (Base t t) t) -> t -> t
module Data.Functor.Classes
cotransverse :: (Recursive s, Corecursive t, Functor f) => (forall a. f (Base s a) -> Base t (f a)) -> f s -> t
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
- Nu :: forall (f :: Type -> Type) a. (a -> f a) -> a -> Nu f
type Algebra f a = f a -> a
type CoAlgebra f a = a -> f a
type RAlgebra f t a = f (t, a) -> a
type RCoAlgebra f t a = a -> f (Either t a)
type (~>) f g = forall a. f a -> g a
type NatM m f g = forall a. f a -> m (g a)
type family HBase (h :: k -> Type) :: (k -> Type) -> k -> Type
type HAlgebra h f = h f ~> f
type HAlgebraM m h f = NatM m (h f) f
type HGAlgebra w h a = h (w a) ~> a
type HGAlgebraM w m h a = NatM m (h (w a)) a
type HCoalgebra h f = f ~> h f
type HCoalgebraM m h f = NatM m f (h f)
type HGCoalgebra m h a = a ~> h (m a)
type HGCoalgebraM n m h a = NatM m a (h (n a))
class HFunctor (h :: (k -> Type) -> k -> Type) where
- hfmap :: (f ~> g) -> h f ~> h g
class HFunctor h => HFoldable (h :: (k -> Type) -> k -> Type) where
- hfoldMap :: Monoid m => (forall b. f b -> m) -> h f a -> m
class HFoldable h => HTraversable (h :: (k -> Type) -> k -> Type) where
- htraverse :: Applicative e => NatM e f g -> NatM e (h f) (h g)
class HFunctor (HBase h) => HRecursive (h :: k -> Type) where
- hproject :: HCoalgebra (HBase h) h
- hcata :: HAlgebra (HBase h) f -> h ~> f
class HFunctor (HBase h) => HCorecursive (h :: k -> Type) where
- hembed :: HAlgebra (HBase h) h
- hana :: HCoalgebra (HBase h) f -> f ~> h
hhylo :: HFunctor f => HAlgebra f b -> HCoalgebra f a -> a ~> b
hcataM :: (Monad m, HTraversable (HBase h), HRecursive h) => HAlgebraM m (HBase h) f -> h a -> m (f a)
hlambek :: (HRecursive h, HCorecursive h) => HCoalgebra (HBase h) h
hpara :: (HFunctor (HBase h), HRecursive h) => HGAlgebra (Product h) (HBase h) a -> h ~> a
hparaM :: (HTraversable (HBase h), HRecursive h, Monad m) => HGAlgebraM (Product h) m (HBase h) a -> NatM m h a
hanaM :: (Monad m, HTraversable (HBase h), HCorecursive h) => HCoalgebraM m (HBase h) f -> f a -> m (h a)
hcolambek :: HRecursive h => HCorecursive h => HAlgebra (HBase h) h
hapo :: HCorecursive h => HGCoalgebra (Sum h) (HBase h) a -> a ~> h
hapoM :: (HCorecursive h, HTraversable (HBase h), Monad m) => HGCoalgebraM (Sum h) m (HBase h) a -> NatM m a h
hhyloM :: (HTraversable t, Monad m) => HAlgebraM m t h -> HCoalgebraM m t f -> f a -> m (h a)

Simple API

type BottomUpT a f = f a -> a Source #

bottomUp :: Recursive t => (Base t a -> a) -> t -> a Source #

Bottom-up traversal (catamorphism)

type BottomUpOrigT t a f = f (t, a) -> a Source #

bottomUpOrig :: Recursive t => (Base t (t, a) -> a) -> t -> a Source #

Bottom-up traversal with original value (paramorphism)

type TopDownStopT a f = f a -> Either (f a) a Source #

topDownStop :: (Recursive t, Corecursive t) => (Base t t -> Either (Base t t) t) -> t -> t Source #

Perform a top-down traversal

Right: stop the traversal ("right" value obtained) Left: continue the traversal recursively on the new value

Recursion schemes

module Data.Functor.Classes

cotransverse :: (Recursive s, Corecursive t, Functor f) => (forall a. f (Base s a) -> Base t (f a)) -> f s -> t #

A coeffectful version of hoist.

Properties:

cotransverse distAna = runIdentity

Examples:

Stateful transformations:

>>> :{
cotransverse
  (\(u, b) -> case b of
    Nil -> Nil
    Cons x a -> Cons (if u then toUpper x else x) (not u, a))
  (True, "foobar") :: String
:}
"FoObAr"

We can implement a variant of zipWith

>>> data Pair a = Pair a a deriving Functor

>>> :{
let zipWith' :: (a -> a -> b) -> [a] -> [a] -> [b]
    zipWith' f xs ys = cotransverse g (Pair xs ys) where
      g (Pair Nil        _)          = Nil
      g (Pair _          Nil)        = Nil
      g (Pair (Cons x a) (Cons y b)) = Cons (f x y) (Pair a b)
    :}

>>> zipWith' (*) [1,2,3] [4,5,6]
[4,10,18]

>>> zipWith' (*) [1,2,3] [4,5,6,8]
[4,10,18]

>>> zipWith' (*) [1,2,3,3] [4,5,6]
[4,10,18]

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/elgot-coalgebras/

elgot :: Functor f => (f a -> a) -> (b -> Either a (f b)) -> b -> a #

Elgot algebras

mhisto :: (forall y. (y -> c) -> (y -> f y) -> f y -> c) -> Fix f -> c #

Mendler-style course-of-value iteration

mcata :: (forall y. (y -> c) -> f y -> c) -> Fix f -> c #

Mendler-style 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 #

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 #

Course-of-value iteration

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 #

Arguments

:: Functor f
=> (f b -> b)
-> f (b, a)	A distributive for semi-mutual recursion
-> (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 #

A specialized, faster version of hoist for Nu.

hoistMu :: (forall a. f a -> g a) -> Mu f -> Mu g #

A specialized, faster version of hoist for Mu.

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 #

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

distAna :: Functor f => Identity (f a) -> f (Identity a) #

gunfold #

Arguments

:: (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)-m-coalgebra
-> a	seed
-> t

A generalized anamorphism

gana #

Arguments

:: (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)-m-coalgebra
-> a	seed
-> t

A generalized anamorphism

distCata :: Functor f => f (Identity a) -> Identity (f a) #

gfold #

Arguments

:: (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)-w-algebra
-> t	fixed point
-> a

A generalized catamorphism

gcata #

Arguments

:: (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)-w-algebra
-> t	fixed point
-> a

A generalized catamorphism

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 #

Instances

type Base Natural
Instance details Defined in Data.Functor.Foldable type Base Natural = Maybe
type Base [a]
Instance details Defined in Data.Functor.Foldable type Base [a] = ListF a
type Base (Maybe a)	Example boring stub for non-recursive data types
Instance details Defined in Data.Functor.Foldable type Base (Maybe a) = (Const (Maybe a) :: Type -> Type)
type Base (NonEmpty a)
Instance details Defined in Data.Functor.Foldable type Base (NonEmpty a) = NonEmptyF a
type Base (Fix f)
Instance details Defined in Data.Functor.Foldable type Base (Fix f) = f
type Base (Mu f)
Instance details Defined in Data.Functor.Foldable type Base (Mu f) = f
type Base (Nu f)
Instance details Defined in Data.Functor.Foldable type Base (Nu f) = f
type Base (Either a b)	Example boring stub for non-recursive data types
Instance details Defined in Data.Functor.Foldable type Base (Either a b) = (Const (Either a b) :: Type -> Type)
type Base (Cofree f a)	Cofree comonads are Recursive/Corecursive
Instance details Defined in Data.Functor.Foldable type Base (Cofree f a) = CofreeF f a
type Base (F f a)	Church encoded free monads are Recursive/Corecursive, in the same way that `Mu` is.
Instance details Defined in Data.Functor.Foldable type Base (F f a) = FreeF f a
type Base (Free f a)	Free monads are Recursive/Corecursive
Instance details Defined in Data.Functor.Foldable type Base (Free f a) = FreeF f a
type Base (FreeT f m a)	Free transformations of monads are Recursive/Corecursive
Instance details Defined in Data.Functor.Foldable type Base (FreeT f m a) = Compose m (FreeF f a)
type Base (CofreeT f w a)	Cofree tranformations of comonads are Recursive/Corecusive
Instance details Defined in Data.Functor.Foldable type Base (CofreeT f w a) = Compose w (CofreeF f a)

class Functor (Base t) => Recursive t where #

Minimal complete definition

Nothing

Methods

project :: t -> Base t t #

cata #

Arguments

:: (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
Instance details Defined in Data.Functor.Foldable Methods 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]
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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 #

Minimal complete definition

Nothing

Methods

embed :: Base t t -> t #

ana #

Arguments

:: (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
Instance details Defined in Data.Functor.Foldable Methods 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]
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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 `F` directly.
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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) #

Constructors

Fix (f (Fix f))

Instances

Eq1 f => Eq (Fix f)
Instance details Defined in Data.Functor.Foldable Methods (==) :: Fix f -> Fix f -> Bool # (/=) :: Fix f -> Fix f -> Bool #
(Typeable f, Data (f (Fix f))) => Data (Fix f)
Instance details Defined in Data.Functor.Foldable Methods 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) # toConstr :: Fix f -> Constr # 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)
Instance details Defined in Data.Functor.Foldable Methods compare :: Fix f -> Fix f -> Ordering # (<) :: Fix f -> Fix f -> Bool # (<=) :: Fix f -> Fix f -> Bool # (>) :: Fix f -> Fix f -> Bool # (>=) :: Fix f -> Fix f -> Bool # max :: Fix f -> Fix f -> Fix f # min :: Fix f -> Fix f -> Fix f #
Read1 f => Read (Fix f)
Instance details Defined in Data.Functor.Foldable Methods readsPrec :: Int -> ReadS (Fix f) # readList :: ReadS [Fix f] # readPrec :: ReadPrec (Fix f) # readListPrec :: ReadPrec [Fix f] #
Show1 f => Show (Fix f)
Instance details Defined in Data.Functor.Foldable Methods showsPrec :: Int -> Fix f -> ShowS # show :: Fix f -> String # showList :: [Fix f] -> ShowS #
Functor f => Recursive (Fix f)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable type Base (Fix f) = f

newtype Mu (f :: Type -> Type) #

Constructors

Mu (forall a. (f a -> a) -> a)

Instances

(Functor f, Eq1 f) => Eq (Mu f)
Instance details Defined in Data.Functor.Foldable Methods (==) :: Mu f -> Mu f -> Bool # (/=) :: Mu f -> Mu f -> Bool #
(Functor f, Ord1 f) => Ord (Mu f)
Instance details Defined in Data.Functor.Foldable Methods compare :: Mu f -> Mu f -> Ordering # (<) :: Mu f -> Mu f -> Bool # (<=) :: Mu f -> Mu f -> Bool # (>) :: Mu f -> Mu f -> Bool # (>=) :: Mu f -> Mu f -> Bool # max :: Mu f -> Mu f -> Mu f # min :: Mu f -> Mu f -> Mu f #
(Functor f, Read1 f) => Read (Mu f)
Instance details Defined in Data.Functor.Foldable Methods readsPrec :: Int -> ReadS (Mu f) # readList :: ReadS [Mu f] # readPrec :: ReadPrec (Mu f) # readListPrec :: ReadPrec [Mu f] #
(Functor f, Show1 f) => Show (Mu f)
Instance details Defined in Data.Functor.Foldable Methods showsPrec :: Int -> Mu f -> ShowS # show :: Mu f -> String # showList :: [Mu f] -> ShowS #
Functor f => Recursive (Mu f)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable type Base (Mu f) = f

data Nu (f :: Type -> Type) where #

Constructors

Nu :: forall (f :: Type -> Type) a. (a -> f a) -> a -> Nu f

Instances

(Functor f, Eq1 f) => Eq (Nu f)
Instance details Defined in Data.Functor.Foldable Methods (==) :: Nu f -> Nu f -> Bool # (/=) :: Nu f -> Nu f -> Bool #
(Functor f, Ord1 f) => Ord (Nu f)
Instance details Defined in Data.Functor.Foldable Methods compare :: Nu f -> Nu f -> Ordering # (<) :: Nu f -> Nu f -> Bool # (<=) :: Nu f -> Nu f -> Bool # (>) :: Nu f -> Nu f -> Bool # (>=) :: Nu f -> Nu f -> Bool # max :: Nu f -> Nu f -> Nu f # min :: Nu f -> Nu f -> Nu f #
(Functor f, Read1 f) => Read (Nu f)
Instance details Defined in Data.Functor.Foldable Methods readsPrec :: Int -> ReadS (Nu f) # readList :: ReadS [Nu f] # readPrec :: ReadPrec (Nu f) # readListPrec :: ReadPrec [Nu f] #
(Functor f, Show1 f) => Show (Nu f)
Instance details Defined in Data.Functor.Foldable Methods showsPrec :: Int -> Nu f -> ShowS # show :: Nu f -> String # showList :: [Nu f] -> ShowS #
Functor f => Recursive (Nu f)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable Methods 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)
Instance details Defined in Data.Functor.Foldable type Base (Nu f) = f