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, Functor m) => Alternative (ListT m)

Monad m => Monad (ListT m)

Functor m => Functor (ListT m)

Monad m => MonadPlus (ListT m)

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

MonadIO m => MonadIO (ListT m)

Monad m => ListMonad (ListT m)

Monad m => Monoid (ListT m a)

data StM (ListT m) = StM (StM m (Maybe (a, 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.

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

Execute, folding to a list in a reverse order. Performs more efficiently than toList.

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

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

splitAt :: (Monad m, ListTrans t, MonadPlus (t m)) => Int -> t m a -> m ([a], t m a)

Execute, consuming a list of the specified length and returning the remainder stream.

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.

type Transformation m a b = forall t. (Monad m, ListMonad (t m), ListTrans t) => t m a -> t m b

A transformation function on a list transformer. It may update the structure or the result type, but the type of the transformer remains the same.

Since it's merely just a function, you can run it by passing a list transformer as an argument.

traverse :: (a -> m b) -> Transformation m a b

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

take :: Int -> Transformation m a a

Produce a transformation, reproducing the behaviour of Data.List.take.

drop :: Int -> Transformation m a a

Produce a transformation, reproducing the behaviour of Data.List.drop.

slice :: Positive Int -> Transformation m a [a]

Produce a transformation, which slices a list into chunks of the specified length.

Positive numbers

data Positive n

A newtype wrapper around a number, which ensures that it is greater than zero.

Instances

Eq n => Eq (Positive n)

Data n => Data (Positive n)

Ord n => Ord (Positive n)

Read n => Read (Positive n)

Show n => Show (Positive n)

Generic (Positive n)

Typeable (* -> *) Positive

type Rep (Positive n)

positive :: (Ord n, Num n) => n -> Maybe (Positive n)

A smart constructor for positive numbers.