Data.Functor.Foldable.Examples

Documentation

data Bert

We call our co-dependent data types Ernie and Bert. They represent mutually recursive

Constructors

Bert Ernie

Num Integer

String String

Add Bert Bert

Instances

Eq Bert

Methods

(==) :: Bert -> Bert -> Bool

(/=) :: Bert -> Bert -> Bool

Show Bert

Methods

showsPrec :: Int -> Bert -> ShowS

show :: Bert -> String

showList :: [Bert] -> ShowS

Generic Bert

Associated Types

type Rep Bert :: * -> *

Methods

from :: Bert -> Rep Bert x

to :: Rep Bert x -> Bert

NFData Bert

Methods

rnf :: Bert -> ()

Recursive Bert

Methods

project :: Bert -> Base Bert Bert

cata :: (Base Bert a -> a) -> Bert -> a

para :: (Base Bert (Bert, a) -> a) -> Bert -> a

gpara :: (Corecursive Bert, Comonad w) => (forall b. Base Bert (w b) -> w (Base Bert b)) -> (Base Bert (EnvT Bert w a) -> a) -> Bert -> a

prepro :: Corecursive Bert => (forall b. Base Bert b -> Base Bert b) -> (Base Bert a -> a) -> Bert -> a

gprepro :: (Corecursive Bert, Comonad w) => (forall b. Base Bert (w b) -> w (Base Bert b)) -> (forall c. Base Bert c -> Base Bert c) -> (Base Bert (w a) -> a) -> Bert -> a

Corecursive Bert

Methods

embed :: Base Bert Bert -> Bert

ana :: (a -> Base Bert a) -> a -> Bert

apo :: (a -> Base Bert (Either Bert a)) -> a -> Bert

postpro :: Recursive Bert => (forall b. Base Bert b -> Base Bert b) -> (a -> Base Bert a) -> a -> Bert

gpostpro :: (Recursive Bert, Monad m) => (forall b. m (Base Bert b) -> Base Bert (m b)) -> (forall c. Base Bert c -> Base Bert c) -> (a -> Base Bert (m a)) -> a -> Bert

Dummy Bert

Methods

dummy :: Bert

SubType Bert

Methods

switch :: Bert -> Bert

SubHom ErnieF BertF Ernie Bert

Methods

homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert

SubHom BertF ErnieF Bert Ernie

Methods

homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie

type Rep Bert

type Rep Bert = D1 (MetaData "Bert" "Data.Functor.Foldable.Examples" "recursion-schemes-ext-0.1.0.4-52WslUf16CTLGRtiZ5urC6" False) ((:+:) ((:+:) (C1 (MetaCons "Bert" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ernie))) (C1 (MetaCons "Num" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Integer)))) ((:+:) (C1 (MetaCons "String" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))) (C1 (MetaCons "Add" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bert)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bert))))))

type Base Bert

type Base Bert = BertF

data Ernie

Constructors

Ernie Bert

Multiply Ernie Ernie

List [Ernie]

Instances

Eq Ernie

Methods

(==) :: Ernie -> Ernie -> Bool

(/=) :: Ernie -> Ernie -> Bool

Show Ernie

Methods

showsPrec :: Int -> Ernie -> ShowS

show :: Ernie -> String

showList :: [Ernie] -> ShowS

Generic Ernie

Associated Types

type Rep Ernie :: * -> *

Methods

from :: Ernie -> Rep Ernie x

to :: Rep Ernie x -> Ernie

NFData Ernie

Methods

rnf :: Ernie -> ()

Recursive Ernie

Methods

project :: Ernie -> Base Ernie Ernie

cata :: (Base Ernie a -> a) -> Ernie -> a

para :: (Base Ernie (Ernie, a) -> a) -> Ernie -> a

gpara :: (Corecursive Ernie, Comonad w) => (forall b. Base Ernie (w b) -> w (Base Ernie b)) -> (Base Ernie (EnvT Ernie w a) -> a) -> Ernie -> a

prepro :: Corecursive Ernie => (forall b. Base Ernie b -> Base Ernie b) -> (Base Ernie a -> a) -> Ernie -> a

gprepro :: (Corecursive Ernie, Comonad w) => (forall b. Base Ernie (w b) -> w (Base Ernie b)) -> (forall c. Base Ernie c -> Base Ernie c) -> (Base Ernie (w a) -> a) -> Ernie -> a

Corecursive Ernie

Methods

embed :: Base Ernie Ernie -> Ernie

ana :: (a -> Base Ernie a) -> a -> Ernie

apo :: (a -> Base Ernie (Either Ernie a)) -> a -> Ernie

postpro :: Recursive Ernie => (forall b. Base Ernie b -> Base Ernie b) -> (a -> Base Ernie a) -> a -> Ernie

gpostpro :: (Recursive Ernie, Monad m) => (forall b. m (Base Ernie b) -> Base Ernie (m b)) -> (forall c. Base Ernie c -> Base Ernie c) -> (a -> Base Ernie (m a)) -> a -> Ernie

Dummy Ernie

Methods

dummy :: Ernie

SubType Ernie

Methods

switch :: Ernie -> Ernie

SubHom ErnieF BertF Ernie Bert

Methods

homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert

SubHom BertF ErnieF Bert Ernie

Methods

homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie

type Rep Ernie

type Rep Ernie = D1 (MetaData "Ernie" "Data.Functor.Foldable.Examples" "recursion-schemes-ext-0.1.0.4-52WslUf16CTLGRtiZ5urC6" False) ((:+:) (C1 (MetaCons "Ernie" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bert))) ((:+:) (C1 (MetaCons "Multiply" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ernie)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ernie)))) (C1 (MetaCons "List" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ernie])))))

type Base Ernie

type Base Ernie = ErnieF

data BertF r

Constructors

BertF Ernie

NumF Integer

StringF String

AddF r r

Instances

Functor BertF

Methods

fmap :: (a -> b) -> BertF a -> BertF b

(<$) :: a -> BertF b -> BertF a

Foldable BertF

Methods

fold :: Monoid m => BertF m -> m

foldMap :: Monoid m => (a -> m) -> BertF a -> m

foldr :: (a -> b -> b) -> b -> BertF a -> b

foldr' :: (a -> b -> b) -> b -> BertF a -> b

foldl :: (b -> a -> b) -> b -> BertF a -> b

foldl' :: (b -> a -> b) -> b -> BertF a -> b

foldr1 :: (a -> a -> a) -> BertF a -> a

foldl1 :: (a -> a -> a) -> BertF a -> a

toList :: BertF a -> [a]

null :: BertF a -> Bool

length :: BertF a -> Int

elem :: Eq a => a -> BertF a -> Bool

maximum :: Ord a => BertF a -> a

minimum :: Ord a => BertF a -> a

sum :: Num a => BertF a -> a

product :: Num a => BertF a -> a

Traversable BertF

Methods

traverse :: Applicative f => (a -> f b) -> BertF a -> f (BertF b)

sequenceA :: Applicative f => BertF (f a) -> f (BertF a)

mapM :: Monad m => (a -> m b) -> BertF a -> m (BertF b)

sequence :: Monad m => BertF (m a) -> m (BertF a)

SubHom ErnieF BertF Ernie Bert

Methods

homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert

SubHom BertF ErnieF Bert Ernie

Methods

homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie

data ErnieF r

Constructors

ErnieF Bert

MultiplyF r r

ListF [r]

Instances

Functor ErnieF

Methods

fmap :: (a -> b) -> ErnieF a -> ErnieF b

(<$) :: a -> ErnieF b -> ErnieF a

Foldable ErnieF

Methods

fold :: Monoid m => ErnieF m -> m

foldMap :: Monoid m => (a -> m) -> ErnieF a -> m

foldr :: (a -> b -> b) -> b -> ErnieF a -> b

foldr' :: (a -> b -> b) -> b -> ErnieF a -> b

foldl :: (b -> a -> b) -> b -> ErnieF a -> b

foldl' :: (b -> a -> b) -> b -> ErnieF a -> b

foldr1 :: (a -> a -> a) -> ErnieF a -> a

foldl1 :: (a -> a -> a) -> ErnieF a -> a

toList :: ErnieF a -> [a]

null :: ErnieF a -> Bool

length :: ErnieF a -> Int

elem :: Eq a => a -> ErnieF a -> Bool

maximum :: Ord a => ErnieF a -> a

minimum :: Ord a => ErnieF a -> a

sum :: Num a => ErnieF a -> a

product :: Num a => ErnieF a -> a

Traversable ErnieF

Methods

traverse :: Applicative f => (a -> f b) -> ErnieF a -> f (ErnieF b)

sequenceA :: Applicative f => ErnieF (f a) -> f (ErnieF a)

mapM :: Monad m => (a -> m b) -> ErnieF a -> m (ErnieF b)

sequence :: Monad m => ErnieF (m a) -> m (ErnieF a)

SubHom ErnieF BertF Ernie Bert

Methods

homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert

SubHom BertF ErnieF Bert Ernie

Methods

homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie

collapseErnieSyntaxTree :: Recursive Ernie => Ernie -> Ernie

Dendromorphism collapsing the tree

collapseErnieSyntaxTree' :: Recursive Ernie => Ernie -> Ernie

Catamorphism, which collapses the tree, but not very well.

collapseBertSyntaxTree :: Recursive Bert => Bert -> Bert

We get two dendromorphisms for the price of one!

collapseBertSyntaxTree' :: Recursive Bert => Bert -> Bert

Another catamorphism that is stupid and lame.