ListT

Documentation

data ListT m a

A proper implementation of a list monad-transformer. Useful for streaming of monadic data structures.

Since it has instances of MonadPlus and Alternative, you can use general utilities packages like "monadplus" with it.

Instances

MFunctor ListT

MonadTrans ListT

ListTrans ListT

MonadBase b m => MonadBase b (ListT m)

MonadBaseControl b m => MonadBaseControl b (ListT m)

Monad m => Monad (ListT m)

Functor m => Functor (ListT m)

Monad m => MonadPlus (ListT m)

(Monad m, Functor m) => Applicative (ListT m)

(Monad m, Functor m) => Alternative (ListT m)

MonadIO m => MonadIO (ListT m)

Monad m => ListMonad (ListT m)

Monad m => Monoid (ListT m a)

Classes

class MonadTrans t => ListTrans t where

A monad transformer capable of executing like a list.

Methods

uncons :: t m a -> m (Maybe (a, t m a))

Execute in the inner monad, getting the head and the tail. Returns nothing if it's empty.

Instances

ListTrans ListT

class MonadPlus m => ListMonad m where

A monad capable of constructing like a list.

Methods

cons :: a -> m a -> m a

Prepend an element.

Instances

ListMonad []

Monad m => ListMonad (ListT m)

ListMonad m => ListMonad (ReaderT e m)

Execution utilities

head :: (Monad m, ListTrans t) => t m a -> m (Maybe a)

Execute, getting the head. Returns nothing if it's empty.

tail :: (Monad m, ListTrans t) => t m a -> m (Maybe (t m a))

Execute, getting the tail. Returns nothing if it's empty.

null :: (Monad m, ListTrans t) => t m a -> m Bool

Execute, checking whether it's empty.

fold :: (Monad m, ListTrans t) => (r -> a -> m r) -> r -> t m a -> m r

Execute, applying a left fold.

toList :: (Monad m, ListTrans t) => t m a -> m [a]

Execute, folding to a list.

traverse_ :: (Monad m, ListTrans t) => (a -> m ()) -> t m a -> m ()

Execute, traversing the stream with a side effect in the inner monad.

Construction utilities

fromFoldable :: (ListMonad m, Foldable f) => f a -> m a

Construct from any foldable.

unfold :: ListMonad m => (b -> Maybe (a, b)) -> b -> m a

Construct by unfolding a pure data structure.

repeat :: ListMonad m => a -> m a

Produce an infinite stream.

Transformation utilities

These utilities only accumulate the transformations without actually traversing the stream. They only get applied with a single traversal, which happens at the execution.

traverse :: (Monad m, ListMonad (t m), ListTrans t) => (a -> m b) -> t m a -> t m b

A transformation, which traverses the stream with an action in the inner monad.

take :: (Monad m, ListMonad (t m), ListTrans t) => Int -> t m a -> t m a

A trasformation, reproducing the behaviour of Data.List.take.

drop :: (Monad m, MonadPlus (t m), ListTrans t) => Int -> t m a -> t m a

A trasformation, reproducing the behaviour of Data.List.drop.