Safe Haskell	None
Language	Haskell2010

Data.Functor.Foldable.Examples

Synopsis

Documentation

data Bert Source #

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 Source #
Methods (==) :: Bert -> Bert -> Bool # (/=) :: Bert -> Bert -> Bool #
Show Bert Source #
Methods showsPrec :: Int -> Bert -> ShowS # show :: Bert -> String # showList :: [Bert] -> ShowS #
Generic Bert Source #
Associated Types type Rep Bert :: * -> * # Methods from :: Bert -> Rep Bert x # to :: Rep Bert x -> Bert #
NFData Bert Source #
Methods rnf :: Bert -> () #
Recursive Bert Source #
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 Source #
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 Source #
Methods dummy :: Bert Source #
SubType Bert Source #
Methods switch :: Bert -> Bert Source #
(Functor ErnieF, Functor BertF) => SubHom ErnieF BertF Ernie Bert Source #
Methods homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert Source #
(Functor BertF, Functor ErnieF) => SubHom BertF ErnieF Bert Ernie Source #
Methods homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie Source #
type Rep Bert Source #
type Rep Bert = D1 (MetaData "Bert" "Data.Functor.Foldable.Examples" "recursion-schemes-ext-0.1.1.0-BWHaii5bKZoAPabDaZjVdp" 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 Source #
type Base Bert = BertF

data Ernie Source #

Constructors

Ernie Bert
Multiply Ernie Ernie
List [Ernie]

Instances

Eq Ernie Source #
Methods (==) :: Ernie -> Ernie -> Bool # (/=) :: Ernie -> Ernie -> Bool #
Show Ernie Source #
Methods showsPrec :: Int -> Ernie -> ShowS # show :: Ernie -> String # showList :: [Ernie] -> ShowS #
Generic Ernie Source #
Associated Types type Rep Ernie :: * -> * # Methods from :: Ernie -> Rep Ernie x # to :: Rep Ernie x -> Ernie #
NFData Ernie Source #
Methods rnf :: Ernie -> () #
Recursive Ernie Source #
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 Source #
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 Source #
Methods dummy :: Ernie Source #
SubType Ernie Source #
Methods switch :: Ernie -> Ernie Source #
(Functor ErnieF, Functor BertF) => SubHom ErnieF BertF Ernie Bert Source #
Methods homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert Source #
(Functor BertF, Functor ErnieF) => SubHom BertF ErnieF Bert Ernie Source #
Methods homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie Source #
type Rep Ernie Source #
type Rep Ernie = D1 (MetaData "Ernie" "Data.Functor.Foldable.Examples" "recursion-schemes-ext-0.1.1.0-BWHaii5bKZoAPabDaZjVdp" 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 Source #
type Base Ernie = ErnieF

data BertF r Source #

Constructors

BertF Ernie
NumF Integer
StringF String
AddF r r

Instances

Functor BertF Source #
Methods fmap :: (a -> b) -> BertF a -> BertF b # (<$) :: a -> BertF b -> BertF a #
Foldable BertF Source #
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 Source #
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) #
(Functor ErnieF, Functor BertF) => SubHom ErnieF BertF Ernie Bert Source #
Methods homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert Source #
(Functor BertF, Functor ErnieF) => SubHom BertF ErnieF Bert Ernie Source #
Methods homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie Source #

data ErnieF r Source #

Constructors

ErnieF Bert
MultiplyF r r
ListF [r]

Instances

Functor ErnieF Source #
Methods fmap :: (a -> b) -> ErnieF a -> ErnieF b # (<$) :: a -> ErnieF b -> ErnieF a #
Foldable ErnieF Source #
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 Source #
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) #
(Functor ErnieF, Functor BertF) => SubHom ErnieF BertF Ernie Bert Source #
Methods homo :: (ErnieF Ernie -> Ernie) -> (BertF Bert -> Bert) -> BertF Bert -> Bert Source #
(Functor BertF, Functor ErnieF) => SubHom BertF ErnieF Bert Ernie Source #
Methods homo :: (BertF Bert -> Bert) -> (ErnieF Ernie -> Ernie) -> ErnieF Ernie -> Ernie Source #

collapseErnieSyntaxTree :: Recursive Ernie => Ernie -> Ernie Source #

Dendromorphism collapsing the tree.

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

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

collapseBertSyntaxTree :: Recursive Bert => Bert -> Bert Source #

We get two dendromorphisms for the price of one!

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

Another catamorphism that is stupid and lame.