Safe Haskell | None |
---|---|
Language | Haskell2010 |
- data ListT m a
- class MonadTrans t => ListTrans t where
- class MonadPlus m => ListMonad m where
- cons :: a -> m a -> m a
- head :: (Monad m, ListTrans t) => t m a -> m (Maybe a)
- tail :: (Monad m, ListTrans t) => t m a -> m (Maybe (t m a))
- null :: (Monad m, ListTrans t) => t m a -> m Bool
- fold :: (Monad m, ListTrans t) => (r -> a -> m r) -> r -> t m a -> m r
- toList :: (Monad m, ListTrans t) => t m a -> m [a]
- toReverseList :: (Monad m, ListTrans t) => t m a -> m [a]
- traverse_ :: (Monad m, ListTrans t) => (a -> m ()) -> t m a -> m ()
- splitAt :: (Monad m, ListTrans t, MonadPlus (t m)) => Int -> t m a -> m ([a], t m a)
- fromFoldable :: (ListMonad m, Foldable f) => f a -> m a
- unfold :: ListMonad m => (b -> Maybe (a, b)) -> b -> m a
- repeat :: ListMonad m => a -> m a
- type Transformation m a b = forall t. (Monad m, ListMonad (t m), ListTrans t) => t m a -> t m b
- traverse :: (a -> m b) -> Transformation m a b
- take :: Int -> Transformation m a a
- drop :: Int -> Transformation m a a
- slice :: Positive Int -> Transformation m a [a]
- data Positive n
- positive :: (Ord n, Num n) => n -> Maybe (Positive n)
Documentation
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.
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 Source
A monad transformer capable of executing like a list.
Execution utilities
head :: (Monad m, ListTrans t) => t m a -> m (Maybe a) Source
Execute, getting the head. Returns nothing if it's empty.
tail :: (Monad m, ListTrans t) => t m a -> m (Maybe (t m a)) Source
Execute, getting the tail. Returns nothing if it's empty.
fold :: (Monad m, ListTrans t) => (r -> a -> m r) -> r -> t m a -> m r Source
Execute, applying a left fold.
toReverseList :: (Monad m, ListTrans t) => t m a -> m [a] Source
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 () Source
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) Source
Execute, consuming a list of the specified length and returning the remainder stream.
Construction utilities
fromFoldable :: (ListMonad m, Foldable f) => f a -> m a Source
Construct from any foldable.
unfold :: ListMonad m => (b -> Maybe (a, b)) -> b -> m a Source
Construct by unfolding a pure data structure.
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 Source
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 Source
Produce a transformation, which traverses the stream with an action in the inner monad.
take :: Int -> Transformation m a a Source
Produce a transformation,
reproducing the behaviour of Data.List.
.take
drop :: Int -> Transformation m a a Source
Produce a transformation,
reproducing the behaviour of Data.List.
.drop
slice :: Positive Int -> Transformation m a [a] Source
Produce a transformation, which slices a list into chunks of the specified length.
Positive numbers
A newtype wrapper around a number, which ensures that it is greater than zero.