Data.Functor.Foldable

Base functors for fixed points

type family Base t :: * -> *

Instances

type Base Natural

type Base Natural = Maybe

type Base [a]

type Base [a] = ListF a

type Base (Maybe a)

type Base (Maybe a) = Const * (Maybe a)

type Base (NonEmpty a)

type Base (NonEmpty a) = NonEmptyF a

type Base (Nu f)

type Base (Nu f) = f

type Base (Mu f)

type Base (Mu f) = f

type Base (Fix f)

type Base (Fix f) = f

type Base (Either a b)

type Base (Either a b) = Const * (Either a b)

type Base (Cofree f a)

type Base (Cofree f a) = CofreeF f a

type Base (F f a)

type Base (F f a) = FreeF f a

type Base (Free f a)

type Base (Free f a) = FreeF f a

type Base (CofreeT f w a)

type Base (CofreeT f w a) = Compose * * w (CofreeF f a)

type Base (FreeT f m a)

type Base (FreeT f m a) = Compose * * m (FreeF f a)

data ListF a b

Base functor of [].

Constructors

Nil

Cons a b

Instances

Eq2 ListF

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> ListF a c -> ListF b d -> Bool

Ord2 ListF

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> ListF a c -> ListF b d -> Ordering

Read2 ListF

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (ListF a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [ListF a b]

Show2 ListF

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> ListF a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [ListF a b] -> ShowS

Bifunctor ListF

Methods

bimap :: (a -> b) -> (c -> d) -> ListF a c -> ListF b d

first :: (a -> b) -> ListF a c -> ListF b c

second :: (b -> c) -> ListF a b -> ListF a c

Bitraversable ListF

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> ListF a b -> f (ListF c d)

Bifoldable ListF

Methods

bifold :: Monoid m => ListF m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> ListF a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> ListF a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> ListF a b -> c

Functor (ListF a)

Methods

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

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

Foldable (ListF a)

Methods

fold :: Monoid m => ListF a m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> ListF a a -> a

foldl1 :: (a -> a -> a) -> ListF a a -> a

toList :: ListF a a -> [a]

null :: ListF a a -> Bool

length :: ListF a a -> Int

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

maximum :: Ord a => ListF a a -> a

minimum :: Ord a => ListF a a -> a

sum :: Num a => ListF a a -> a

product :: Num a => ListF a a -> a

Traversable (ListF a)

Methods

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

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

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

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

Generic1 (ListF a)

Associated Types

type Rep1 (ListF a :: * -> *) :: * -> *

Methods

from1 :: ListF a a -> Rep1 (ListF a) a

to1 :: Rep1 (ListF a) a -> ListF a a

Eq a => Eq1 (ListF a)

Methods

liftEq :: (a -> b -> Bool) -> ListF a a -> ListF a b -> Bool

Ord a => Ord1 (ListF a)

Methods

liftCompare :: (a -> b -> Ordering) -> ListF a a -> ListF a b -> Ordering

Read a => Read1 (ListF a)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ListF a a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ListF a a]

Show a => Show1 (ListF a)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ListF a a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ListF a a] -> ShowS

(Eq b, Eq a) => Eq (ListF a b)

Methods

(==) :: ListF a b -> ListF a b -> Bool

(/=) :: ListF a b -> ListF a b -> Bool

(Ord b, Ord a) => Ord (ListF a b)

Methods

compare :: ListF a b -> ListF a b -> Ordering

(<) :: ListF a b -> ListF a b -> Bool

(<=) :: ListF a b -> ListF a b -> Bool

(>) :: ListF a b -> ListF a b -> Bool

(>=) :: ListF a b -> ListF a b -> Bool

max :: ListF a b -> ListF a b -> ListF a b

min :: ListF a b -> ListF a b -> ListF a b

(Read b, Read a) => Read (ListF a b)

Methods

readsPrec :: Int -> ReadS (ListF a b)

readList :: ReadS [ListF a b]

readPrec :: ReadPrec (ListF a b)

readListPrec :: ReadPrec [ListF a b]

(Show b, Show a) => Show (ListF a b)

Methods

showsPrec :: Int -> ListF a b -> ShowS

show :: ListF a b -> String

showList :: [ListF a b] -> ShowS

Generic (ListF a b)

Associated Types

type Rep (ListF a b) :: * -> *

Methods

from :: ListF a b -> Rep (ListF a b) x

to :: Rep (ListF a b) x -> ListF a b

type Rep1 (ListF a)

type Rep1 (ListF a) = D1 (MetaData "ListF" "Data.Functor.Foldable" "recursion-schemes-5.0.2-HSIBLYBwgfJHnWxEt5tPKC" False) ((:+:) (C1 (MetaCons "Nil" PrefixI False) U1) (C1 (MetaCons "Cons" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep (ListF a b)

type Rep (ListF a b) = D1 (MetaData "ListF" "Data.Functor.Foldable" "recursion-schemes-5.0.2-HSIBLYBwgfJHnWxEt5tPKC" False) ((:+:) (C1 (MetaCons "Nil" PrefixI False) U1) (C1 (MetaCons "Cons" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 b)))))

Fixed points

newtype Fix f

Constructors

Fix (f (Fix f))

Instances

Eq1 f => Eq (Fix f)

Methods

(==) :: Fix f -> Fix f -> Bool

(/=) :: Fix f -> Fix f -> Bool

(Typeable (* -> *) f, Data (f (Fix f))) => Data (Fix f)

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)

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)

Methods

readsPrec :: Int -> ReadS (Fix f)

readList :: ReadS [Fix f]

readPrec :: ReadPrec (Fix f)

readListPrec :: ReadPrec [Fix f]

Show1 f => Show (Fix f)

Methods

showsPrec :: Int -> Fix f -> ShowS

show :: Fix f -> String

showList :: [Fix f] -> ShowS

Functor f => Corecursive (Fix f)

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 => Recursive (Fix f)

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

type Base (Fix f)

type Base (Fix f) = f

unfix :: Fix f -> f (Fix f)

newtype Mu f

Constructors

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

Instances

(Functor f, Eq1 f) => Eq (Mu f)

Methods

(==) :: Mu f -> Mu f -> Bool

(/=) :: Mu f -> Mu f -> Bool

(Functor f, Ord1 f) => Ord (Mu f)

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)

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)

Methods

showsPrec :: Int -> Mu f -> ShowS

show :: Mu f -> String

showList :: [Mu f] -> ShowS

Functor f => Corecursive (Mu f)

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 => Recursive (Mu f)

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

type Base (Mu f)

type Base (Mu f) = f

data Nu f where

Constructors

Nu :: (a -> f a) -> a -> Nu f

Instances

(Functor f, Eq1 f) => Eq (Nu f)

Methods

(==) :: Nu f -> Nu f -> Bool

(/=) :: Nu f -> Nu f -> Bool

(Functor f, Ord1 f) => Ord (Nu f)

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)

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)

Methods

showsPrec :: Int -> Nu f -> ShowS

show :: Nu f -> String

showList :: [Nu f] -> ShowS

Functor f => Corecursive (Nu f)

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

Functor f => Recursive (Nu f)

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

type Base (Nu f)

type Base (Nu f) = f

Folding

class Functor (Base t) => Recursive t where

Minimal complete definition

project

Methods

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

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

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]

Methods

project :: [a] -> Base [a] [a]

cata :: (Base [a] a -> a) -> [a] -> a

para :: (Base [a] ([a], a) -> a) -> [a] -> a

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

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

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 a) -> a) -> [a] -> a

Recursive (Maybe a)

Methods

project :: Maybe a -> Base (Maybe a) (Maybe a)

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

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

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 a) -> a) -> Maybe a -> a

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

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 a) -> a) -> Maybe a -> a

Recursive (NonEmpty a)

Methods

project :: NonEmpty a -> Base (NonEmpty a) (NonEmpty a)

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

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

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 a) -> a) -> NonEmpty a -> a

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

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 a) -> a) -> NonEmpty a -> a

Functor f => Recursive (Nu f)

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 => Recursive (Mu f)

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 (Fix f)

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

Recursive (Either a b)

Methods

project :: Either a b -> Base (Either a b) (Either a b)

cata :: (Base (Either a b) a -> a) -> Either a b -> a

para :: (Base (Either a b) (Either a b, a) -> a) -> Either a b -> a

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

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

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

Functor f => Recursive (Cofree f a)

Methods

project :: Cofree f a -> Base (Cofree f a) (Cofree f a)

cata :: (Base (Cofree f a) a -> a) -> Cofree f a -> a

para :: (Base (Cofree f a) (Cofree f a, a) -> a) -> Cofree f a -> a

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 a) -> a) -> Cofree f a -> a

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

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 a) -> a) -> Cofree f a -> a

Functor f => Recursive (F f a)

Methods

project :: F f a -> Base (F f a) (F f a)

cata :: (Base (F f a) a -> a) -> F f a -> a

para :: (Base (F f a) (F f a, a) -> a) -> F f a -> a

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 a) -> a) -> F f a -> a

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

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 a) -> a) -> F f a -> a

Functor f => Recursive (Free f a)

Methods

project :: Free f a -> Base (Free f a) (Free f a)

cata :: (Base (Free f a) a -> a) -> Free f a -> a

para :: (Base (Free f a) (Free f a, a) -> a) -> Free f a -> a

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 a) -> a) -> Free f a -> a

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

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 a) -> a) -> Free f a -> a

(Functor w, Functor f) => Recursive (CofreeT f w a)

Methods

project :: CofreeT f w a -> Base (CofreeT f w a) (CofreeT f w a)

cata :: (Base (CofreeT f w a) a -> a) -> CofreeT f w a -> a

para :: (Base (CofreeT f w a) (CofreeT f w a, a) -> a) -> CofreeT f w a -> a

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

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) a -> a) -> CofreeT f w a -> a

gprepro :: (Corecursive (CofreeT f w a), Comonad w) => (forall b. Base (CofreeT f w a) (w b) -> w (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) (w a) -> a) -> CofreeT f w a -> a

(Functor m, Functor f) => Recursive (FreeT f m a)

Methods

project :: FreeT f m a -> Base (FreeT f m a) (FreeT f m a)

cata :: (Base (FreeT f m a) a -> a) -> FreeT f m a -> a

para :: (Base (FreeT f m a) (FreeT f m a, a) -> a) -> FreeT f m a -> a

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 a) -> a) -> FreeT f m a -> a

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) a -> a) -> FreeT f m a -> a

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 a) -> a) -> FreeT f m a -> a

Combinators

gapo :: Corecursive t => (b -> Base t b) -> (a -> Base t (Either b a)) -> a -> t

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

zygo :: Recursive t => (Base t b -> b) -> (Base t (b, a) -> a) -> t -> 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

histo :: Recursive t => (Base t (Cofree (Base t) a) -> a) -> t -> a

Course-of-value iteration

ghisto :: (Recursive t, Functor h) => (forall b. Base t (h b) -> h (Base t b)) -> (Base t (Cofree h a) -> a) -> t -> a

futu :: Corecursive t => (a -> Base t (Free (Base t) a)) -> a -> t

chrono :: Functor f => (f (Cofree f b) -> b) -> (a -> f (Free f a)) -> a -> b

gchrono :: (Functor f, Functor w, Functor m) => (forall c. f (w c) -> w (f c)) -> (forall c. m (f c) -> f (m c)) -> (f (Cofree w b) -> b) -> (a -> f (Free m a)) -> a -> b

Distributive laws

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

distPara :: Corecursive t => Base t (t, a) -> (t, Base t a)

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)

distZygo

Arguments

:: Functor f

=> (f b -> b)

-> f (b, a) -> (b, f a)

A distributive for semi-mutual recursion

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)

distHisto :: Functor f => f (Cofree f a) -> Cofree f (f a)

distGHisto :: (Functor f, Functor h) => (forall b. f (h b) -> h (f b)) -> f (Cofree h a) -> Cofree h (f a)

distFutu :: Functor f => Free f (f a) -> f (Free f a)

distGFutu :: (Functor f, Functor h) => (forall b. h (f b) -> f (h b)) -> Free h (f a) -> f (Free h a)

Unfolding

class Functor (Base t) => Corecursive t where

Minimal complete definition

embed

Methods

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

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

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]

Methods

embed :: Base [a] [a] -> [a]

ana :: (a -> Base [a] a) -> a -> [a]

apo :: (a -> Base [a] (Either [a] a)) -> a -> [a]

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

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

Corecursive (Maybe a)

Methods

embed :: Base (Maybe a) (Maybe a) -> Maybe a

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

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

postpro :: Recursive (Maybe a) => (forall b. Base (Maybe a) b -> Base (Maybe a) b) -> (a -> Base (Maybe a) a) -> a -> 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) -> (a -> Base (Maybe a) (m a)) -> a -> Maybe a

Corecursive (NonEmpty a)

Methods

embed :: Base (NonEmpty a) (NonEmpty a) -> NonEmpty a

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

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

postpro :: Recursive (NonEmpty a) => (forall b. Base (NonEmpty a) b -> Base (NonEmpty a) b) -> (a -> Base (NonEmpty a) a) -> a -> 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) -> (a -> Base (NonEmpty a) (m a)) -> a -> NonEmpty a

Functor f => Corecursive (Nu f)

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

Functor f => Corecursive (Mu f)

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 (Fix f)

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

Corecursive (Either a b)

Methods

embed :: Base (Either a b) (Either a b) -> Either a b

ana :: (a -> Base (Either a b) a) -> a -> Either a b

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

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

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

Functor f => Corecursive (Cofree f a)

Methods

embed :: Base (Cofree f a) (Cofree f a) -> Cofree f a

ana :: (a -> Base (Cofree f a) a) -> a -> Cofree f a

apo :: (a -> Base (Cofree f a) (Either (Cofree f a) a)) -> a -> Cofree f a

postpro :: Recursive (Cofree f a) => (forall b. Base (Cofree f a) b -> Base (Cofree f a) b) -> (a -> Base (Cofree f a) a) -> a -> 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) -> (a -> Base (Cofree f a) (m a)) -> a -> Cofree f a

Functor f => Corecursive (F f a)

Methods

embed :: Base (F f a) (F f a) -> F f a

ana :: (a -> Base (F f a) a) -> a -> F f a

apo :: (a -> Base (F f a) (Either (F f a) a)) -> a -> F f a

postpro :: Recursive (F f a) => (forall b. Base (F f a) b -> Base (F f a) b) -> (a -> Base (F f a) a) -> a -> 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) -> (a -> Base (F f a) (m a)) -> a -> F f a

Functor f => Corecursive (Free f a)

It may be better to work with the instance for F directly.

Methods

embed :: Base (Free f a) (Free f a) -> Free f a

ana :: (a -> Base (Free f a) a) -> a -> Free f a

apo :: (a -> Base (Free f a) (Either (Free f a) a)) -> a -> Free f a

postpro :: Recursive (Free f a) => (forall b. Base (Free f a) b -> Base (Free f a) b) -> (a -> Base (Free f a) a) -> a -> 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) -> (a -> Base (Free f a) (m a)) -> a -> Free f a

(Functor w, Functor f) => Corecursive (CofreeT f w a)

Methods

embed :: Base (CofreeT f w a) (CofreeT f w a) -> CofreeT f w a

ana :: (a -> Base (CofreeT f w a) a) -> a -> CofreeT f w a

apo :: (a -> Base (CofreeT f w a) (Either (CofreeT f w a) a)) -> a -> CofreeT f w a

postpro :: Recursive (CofreeT f w a) => (forall b. Base (CofreeT f w a) b -> Base (CofreeT f w a) b) -> (a -> Base (CofreeT f w a) a) -> a -> 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) -> (a -> Base (CofreeT f w a) (m a)) -> a -> CofreeT f w a

(Functor m, Functor f) => Corecursive (FreeT f m a)

Methods

embed :: Base (FreeT f m a) (FreeT f m a) -> FreeT f m a

ana :: (a -> Base (FreeT f m a) a) -> a -> FreeT f m a

apo :: (a -> Base (FreeT f m a) (Either (FreeT f m a) a)) -> a -> FreeT f m a

postpro :: Recursive (FreeT f m a) => (forall b. Base (FreeT f m a) b -> Base (FreeT f m a) b) -> (a -> Base (FreeT f m a) a) -> a -> FreeT f m a

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

Combinators

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

Distributive laws

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

distApo :: Recursive t => Either t (Base t a) -> Base t (Either t a)

distGApo :: Functor f => (b -> f b) -> Either b (f a) -> f (Either b 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)

Refolding

hylo :: Functor f => (f b -> b) -> (a -> f 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

A generalized hylomorphism

Changing representation

refix :: (Recursive s, Corecursive t, Base s ~ Base t) => s -> t

Common names

fold :: Recursive t => (Base t a -> a) -> t -> 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

unfold :: Corecursive t => (a -> Base t a) -> a -> t

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

refold :: Functor f => (f b -> b) -> (a -> f a) -> a -> b

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

Mendler-style

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

Mendler-style iteration

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

Mendler-style course-of-value iteration

Elgot (co)algebras

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

Elgot algebras

coelgot :: Functor f => ((a, f b) -> b) -> (a -> f a) -> a -> b

Elgot coalgebras: http://comonad.com/reader/2008/elgot-coalgebras/

Zygohistomorphic prepromorphisms

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