Algebra.Monad.Free

Documentation

data Free f a

Constructors

Join (f (Free f a))

Pure a

Instances

ConcreteMonad Free

MonadTrans Free

MonadCounter w a m => MonadCounter w a (Free m)

MonadFuture m t => MonadFuture m (Free t)

MonadError e m => MonadError e (Free m)

MonadWriter w m => MonadWriter w (Free m)

MonadReader r m => MonadReader r (Free m)

MonadState s m => MonadState s (Free m)

MonadFree m (Free m)

Unit (Free f)

MonadList m => MonadList (Free m)

MonadIO m => MonadIO (Free m)

MonadFix f => MonadFix (Free f)

Traversable f => Traversable (Free f)

Foldable f => Foldable (Free f)

Comonad f => Comonad (Free f)

Counit f => Counit (Free f)

Functor f => Monad (Free f)

Functor f => Applicative (Free f)

Functor f => Functor (Free f)

(Ord (f (Free f a)), Ord a, Unit f) => Eq (Free f a)

(Ord (f (Free f a)), Ord a, Unit f) => Ord (Free f a)

(Show (f (Free f a)), Show a) => Show (Free f a)

concrete :: Monad m => Free m a -> m (Free Id a)

unliftF :: Monad m => Free m a -> Free m (m a)

mapF :: (Functor f, Functor g) => (forall a. f a -> g a) -> Free f b -> Free g b

class MonadFree m f | f -> m where

Methods

step :: Monad m => f a -> m (f a)

perform :: Monad m => f a -> m a

liftF :: Functor m => m a -> f a

Instances

MonadFree m (Free m)

coerceStep :: forall m f g a. (Monad m, MonadFree m f) => (f a -> g a) -> g a -> m (g a)

coercePerform :: forall m f g a. (Monad m, MonadFree m f) => (f a -> g a) -> g a -> m a

coerceLiftF :: forall m f g a. (Functor m, MonadFree m f) => (f a -> g a) -> m a -> g a

data Cofree w a

Constructors

Step a (w (Cofree w a))

Instances

Unit m => Unit (Cofree m)

Traversable w => Traversable (Cofree w)

Foldable w => Foldable (Cofree w)

Functor w => Comonad (Cofree w)

Counit (Cofree w)

Applicative m => Monad (Cofree m)

Applicative m => Applicative (Cofree m)

Functor w => Functor (Cofree w)

type Infinite a = Cofree Id a

type Colist a = Cofree Maybe a

type Bifree f a = Cofree (Free f) a

newtype ContC k a b

Constructors

ContC

Fields

runContC :: forall c. k b c -> k a c

Instances

Category (ContC k)

Deductive (ContC k)

contC :: (Category k, Category k') => Iso (ContC k a b) (ContC k' a' b') (k a b) (k' a' b')