haskus-utils-data-1.3: Haskus data utility modules

Safe HaskellNone
LanguageHaskell2010

Haskus.Utils.Functor

Contents

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

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

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 :: 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 [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

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

(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

(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

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

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

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

type RCoAlgebra f t a = a -> f (Either t a) Source #

Higher-order recursion schemes

type (~>) f g = forall a. f a -> g a Source #

type NatM m f g = forall a. f a -> m (g a) Source #

type family HBase (h :: k -> Type) :: (k -> Type) -> k -> Type Source #

type HAlgebra h f = h f ~> f Source #

type HAlgebraM m h f = NatM m (h f) f Source #

type HGAlgebra w h a = h (w a) ~> a Source #

type HGAlgebraM w m h a = NatM m (h (w a)) a Source #

type HCoalgebra h f = f ~> h f Source #

type HCoalgebraM m h f = NatM m f (h f) Source #

type HGCoalgebra m h a = a ~> h (m a) Source #

type HGCoalgebraM n m h a = NatM m a (h (n a)) Source #

class HFunctor (h :: (k -> Type) -> k -> Type) where Source #

Methods

hfmap :: (f ~> g) -> h f ~> h g Source #

class HFunctor h => HFoldable (h :: (k -> Type) -> k -> Type) where Source #

Methods

hfoldMap :: Monoid m => (forall b. f b -> m) -> h f a -> m Source #

class HFoldable h => HTraversable (h :: (k -> Type) -> k -> Type) where Source #

Methods

htraverse :: Applicative e => NatM e f g -> NatM e (h f) (h g) Source #

class HFunctor (HBase h) => HRecursive (h :: k -> Type) where Source #

Minimal complete definition

hproject

Methods

hproject :: HCoalgebra (HBase h) h Source #

hcata :: HAlgebra (HBase h) f -> h ~> f Source #

class HFunctor (HBase h) => HCorecursive (h :: k -> Type) where Source #

Minimal complete definition

hembed

Methods

hembed :: HAlgebra (HBase h) h Source #

hana :: HCoalgebra (HBase h) f -> f ~> h Source #

hhylo :: HFunctor f => HAlgebra f b -> HCoalgebra f a -> a ~> b Source #

hcataM :: (Monad m, HTraversable (HBase h), HRecursive h) => HAlgebraM m (HBase h) f -> h a -> m (f a) Source #

hpara :: (HFunctor (HBase h), HRecursive h) => HGAlgebra (Product h) (HBase h) a -> h ~> a Source #

hparaM :: (HTraversable (HBase h), HRecursive h, Monad m) => HGAlgebraM (Product h) m (HBase h) a -> NatM m h a Source #

hanaM :: (Monad m, HTraversable (HBase h), HCorecursive h) => HCoalgebraM m (HBase h) f -> f a -> m (h a) Source #

hapo :: HCorecursive h => HGCoalgebra (Sum h) (HBase h) a -> a ~> h Source #

hapoM :: (HCorecursive h, HTraversable (HBase h), Monad m) => HGCoalgebraM (Sum h) m (HBase h) a -> NatM m a h Source #

hhyloM :: (HTraversable t, Monad m) => HAlgebraM m t h -> HCoalgebraM m t f -> f a -> m (h a) Source #