Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- newtype ListT m a = ListT (m (Maybe (a, ListT m a)))
- uncons :: ListT m a -> m (Maybe (a, ListT m a))
- head :: Monad m => ListT m a -> m (Maybe a)
- tail :: Monad m => ListT m a -> m (Maybe (ListT m a))
- null :: Monad m => ListT m a -> m Bool
- fold :: Monad m => (r -> a -> m r) -> r -> ListT m a -> m r
- foldMaybe :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r
- applyFoldM :: Monad m => FoldM m i o -> ListT m i -> m o
- toList :: Monad m => ListT m a -> m [a]
- toReverseList :: Monad m => ListT m a -> m [a]
- traverse_ :: Monad m => (a -> m ()) -> ListT m a -> m ()
- splitAt :: Monad m => Int -> ListT m a -> m ([a], ListT m a)
- cons :: Monad m => a -> ListT m a -> ListT m a
- fromFoldable :: (Monad m, Foldable f) => f a -> ListT m a
- fromMVar :: MonadIO m => MVar (Maybe a) -> ListT m a
- unfold :: Monad m => (b -> Maybe (a, b)) -> b -> ListT m a
- unfoldM :: Monad m => (b -> m (Maybe (a, b))) -> b -> ListT m a
- repeat :: Monad m => a -> ListT m a
- traverse :: Monad m => (a -> m b) -> ListT m a -> ListT m b
- take :: Monad m => Int -> ListT m a -> ListT m a
- drop :: Monad m => Int -> ListT m a -> ListT m a
- slice :: Monad m => Int -> ListT m a -> ListT m [a]

# Documentation

A proper implementation of the 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

MMonad ListT Source # | |

MonadTrans ListT Source # | |

MonadBase b m => MonadBase b (ListT m) Source # | |

MonadBaseControl b m => MonadBaseControl b (ListT m) Source # | |

MonadError e m => MonadError e (ListT m) Source # | |

Defined in ListT throwError :: e -> ListT m a # catchError :: ListT m a -> (e -> ListT m a) -> ListT m a # | |

Monad m => Monad (ListT m) Source # | |

Functor m => Functor (ListT m) Source # | |

Monad m => MonadFail (ListT m) Source # | |

(Monad m, Functor m) => Applicative (ListT m) Source # | |

MonadIO m => MonadIO (ListT m) Source # | |

(Monad m, Functor m) => Alternative (ListT m) Source # | |

Monad m => MonadPlus (ListT m) Source # | |

MFunctor ListT Source # | |

Monad m => Semigroup (ListT m a) Source # | |

Monad m => Monoid (ListT m a) Source # | |

type StM (ListT m) a Source # | |

# Execution utilities

uncons :: ListT m a -> m (Maybe (a, ListT m a)) Source #

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

head :: Monad m => ListT m a -> m (Maybe a) Source #

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

tail :: Monad m => ListT m a -> m (Maybe (ListT m a)) Source #

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

foldMaybe :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r Source #

A version of `fold`

, which allows early termination.

applyFoldM :: Monad m => FoldM m i o -> ListT m i -> m o Source #

Apply a left fold abstraction from the "foldl" package.

toReverseList :: Monad m => ListT m a -> m [a] Source #

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

.

traverse_ :: Monad m => (a -> m ()) -> ListT m a -> m () Source #

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

splitAt :: Monad m => Int -> ListT m a -> m ([a], ListT m a) Source #

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

# Construction utilities

fromMVar :: MonadIO m => MVar (Maybe a) -> ListT m a Source #

Construct from an MVar, interpreting the value of Nothing as the end.

unfold :: Monad m => (b -> Maybe (a, b)) -> b -> ListT m a Source #

Construct by unfolding a pure data structure.

unfoldM :: Monad m => (b -> m (Maybe (a, b))) -> b -> ListT m a Source #

Construct by unfolding a monadic data structure

This is the most memory-efficient way to construct ListT where the length depends on the inner monad.

# Transformation utilities

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

traverse :: Monad m => (a -> m b) -> ListT m a -> ListT m b Source #

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

take :: Monad m => Int -> ListT m a -> ListT m a Source #

A transformation,
reproducing the behaviour of `Data.List.`

.`take`