recursion-schemes-ext-0.1.1.1: Amateur addenda to recursion-schemes

Safe HaskellNone
LanguageHaskell2010

Data.Functor.Foldable.Examples

Contents

Description

This module contains an example used by the test suite.

Synopsis

Data Types

data Bert Source #

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

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 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 Base Ernie Source # 

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 #

Catamorphisms

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

Dendromorphism collapsing the tree. Note that we can use the same F-algebras here as we would in a normal catamorphism.

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

Catamorphism, which collapses the tree the usual way.

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

We can generate two functions by swapping the F-algebras and the dummy type.