Control.Monad.Free.Trans

data FreeT :: (Type -> Type) -> (Type -> Type) -> Type -> Typedata FreeT f m a

The free monad transformer for the functor f.

Instances

• (Functor f, Functor m) => Functor (FreeT f m)
• (Functor f, Monad m) => Apply (FreeT f m)
• (Functor f, Monad m) => Applicative (FreeT f m)
• (Functor f, Monad m) => Bind (FreeT f m)
• (Functor f, Monad m) => Monad (FreeT f m)
• (Functor f) => MonadTrans (FreeT f)
• (Functor f, Monad m) => MonadRec (FreeT f m)
• (Functor f, Monad m, Semigroup w) => Semigroup (FreeT f m w)
• (Functor f, Monad m, Monoid w) => Monoid (FreeT f m w)
• (Functor f, MonadEffect m) => MonadEffect (FreeT f m)
• (Functor f, MonadAff m) => MonadAff (FreeT f m)
• (Functor f, MonadAsk r m) => MonadAsk r (FreeT f m)
• (Functor f, MonadTell w m) => MonadTell w (FreeT f m)
• (Functor f, MonadState s m) => MonadState s (FreeT f m)
• (Functor f, MonadThrow e m) => MonadThrow e (FreeT f m)

freeT :: forall f m a. (Unit -> m (Either a (f (FreeT f m a)))) -> FreeT f m a

Construct a computation of type FreeT.

liftFreeT :: forall f m a. Functor f => Monad m => f a -> FreeT f m a

Lift an action from the functor f to a FreeT action.

hoistFreeT :: forall f m n a. Functor f => Functor n => (m ~> n) -> FreeT f m a -> FreeT f n a

Change the underlying Monad for a FreeT action.

interpret :: forall f g m a. Functor f => Functor m => (f ~> g) -> FreeT f m a -> FreeT g m a

Change the base functor f for a FreeT action.

bimapFreeT :: forall f g m n a. Functor f => Functor n => (f ~> g) -> (m ~> n) -> FreeT f m a -> FreeT g n a

Change the base functor f and the underlying Monad for a FreeT action.

substFreeT :: forall a m f g. Monad m => Functor g => (f ~> (FreeT g m)) -> FreeT f m a -> FreeT g m a

Like runFreeT, but for running into some other FreeT without the overhead that MonadRec incurs.

resume :: forall f m a. Functor f => MonadRec m => FreeT f m a -> m (Either a (f (FreeT f m a)))

Unpack FreeT, exposing the first step of the computation.

runFreeT :: forall f m a. Functor f => MonadRec m => (f (FreeT f m a) -> m (FreeT f m a)) -> FreeT f m a -> m a

Run a FreeT computation to completion.