definitive-base-2.3: The base modules of the Definitive framework.

Safe HaskellNone



data Free f a Source


Join (f (Free f a)) 
Pure a 


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) Source

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

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

class MonadFree m f | f -> m where Source


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

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

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


MonadFree m (Free m) 

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

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

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

data Cofree w a Source


Step a (w (Cofree w a)) 

type Bifree f a = Cofree (Free f) a Source

newtype ContC k a b Source




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


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