Control.Monad.Free

Documentation

module Control.Monad

Free Monads

class (Functor f, Monad m) => MonadFree f m where

This type class generalizes over encodings of Free Monads.

Methods

free

Arguments

:: m a

-> m (Either a (f (m a)))

Opens a computation and allows to observe the side effects

wrap

Arguments

:: f (m a)

-> m a

Wraps a side effect into a monadic computation

Instances

Functor f => MonadFree f (Free f)

(Monad m, Functor f) => MonadFree f (C (FreeT f m))

Functor f => MonadFree f (C (Free f))

(Functor f, Monad m) => MonadFree f (FreeT f m)

data Free f a

Constructors

Impure (f (Free f a))

Pure a

Instances

Functor f => MonadFree f (Free f)

Functor f => MonadFree f (C (Free f))

Functor f => Monad (Free f)

Functor f => Functor (Free f)

Functor f => Applicative (Free f)

(Functor f, Foldable f) => Foldable (Free f)

Traversable f => Traversable (Free f)

Eq1 f => Eq1 (Free f)

Ord1 f => Ord1 (Free f)

(Eq a, Eq1 f) => Eq (Free f a)

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

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

Generic (Free f a)

Typeable ((* -> *) -> * -> *) Free

type Rep (Free f a)

isPure :: Free t t1 -> Bool

isImpure :: Free t t1 -> Bool

foldFree :: Functor f => (a -> b) -> (f b -> b) -> Free f a -> b

evalFree :: (a -> b) -> (f (Free f a) -> b) -> Free f a -> b

mapFree :: (Functor f, Functor g) => (f (Free g a) -> g (Free g a)) -> Free f a -> Free g a

mapFreeM :: (Traversable f, Functor g, Monad m) => (f (Free g a) -> m (g (Free g a))) -> Free f a -> m (Free g a)

mapFreeM' :: (Functor f, Traversable g, Monad m) => (forall a. f a -> m (g a)) -> Free f a -> m (Free g a)

Monad Morphisms

foldFreeM :: (Traversable f, Monad m) => (a -> m b) -> (f b -> m b) -> Free f a -> m b

induce :: (Functor f, Monad m) => (forall a. f a -> m a) -> Free f a -> m a

Free Monad Transformers

newtype FreeT f m a

Constructors

FreeT

Fields

unFreeT :: m (Either a (f (FreeT f m a)))

Instances

(Monad m, Functor f) => MonadFree f (C (FreeT f m))

(Functor f, Monad m) => MonadFree f (FreeT f m)

Functor f => MonadTrans (FreeT f)

(Functor f, Monad m) => Monad (FreeT f m)

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

(Functor f, Monad m, MonadPlus m) => MonadPlus (FreeT f m)

(Functor f, Functor a, Monad a) => Applicative (FreeT f a)

(Traversable m, Traversable f) => Foldable (FreeT f m)

(Traversable m, Traversable f) => Traversable (FreeT f m)

(Functor f, Monad m, MonadIO m) => MonadIO (FreeT f m)

foldFreeT :: (Traversable f, Monad m) => (a -> m b) -> (f b -> m b) -> FreeT f m a -> m b

foldFreeT' :: (Traversable f, Monad m) => (a -> b) -> (f b -> b) -> FreeT f m a -> m b

mapFreeT :: (Functor f, Functor m) => (forall a. m a -> m' a) -> FreeT f m a -> FreeT f m' a

foldFreeA :: (Traversable f, Applicative m) => (a -> m b) -> m (f b -> b) -> Free f a -> m b

mapFreeA :: (Traversable f, Functor g, Applicative m) => m (f (Free g a) -> g (Free g a)) -> Free f a -> m (Free g a)

Translate between Free monad and Free monad transformer computations

trans :: MonadFree f m => Free f a -> m a

trans' :: (Functor f, Monad m) => m (Free f a) -> FreeT f m a

untrans :: (Traversable f, Monad m) => FreeT f m a -> m (Free f a)

liftFree :: (Functor f, Monad m) => (a -> Free f b) -> a -> FreeT f m b