Data.Stream.Monadic

(Mostly mechanical) adaptation of the Data.Stream module from the stream-fusion package to a monadic Stream datatype similar to the one proposed by Michael Snoyman for the conduit package.

The intention here is to provide a high-level, Data.List-like interface to Database.LevelDB.Iterators with predictable space and time complexity (see Database.LevelDB.Streaming), and without introducing a dependency eg. on one of the streaming libraries (all relevant datatypes are fully exported, though, so it should be straightforward to write wrappers for your favourite streaming library).

Fusion and inlining rules and strictness annotations have been put in place faithfully, and may need further profiling. Also, some functions (from Data.List) have been omitted as either no obvious solution exists (notably mapM), they didn't seem too useful in the given context (eg. lookup), or I was just too lazy. Missing functions may be added upon request.

Documentation

data Step a s

Constructors

Yield a !s

Skip !s

Done

data Stream m a

Constructors

forall s . Stream (s -> m (Step a s)) (m s)

Instances

Monad m => Functor (Stream m)

Conversion with lists

toList :: (Functor m, Monad m) => Stream m a -> m [a]

fromList :: Monad m => [a] -> Stream m a

Basic functions

append :: (Functor m, Monad m) => Stream m a -> Stream m a -> Stream m a

cons :: (Functor m, Monad m) => a -> Stream m a -> Stream m a

snoc :: (Functor m, Monad m) => Stream m a -> a -> Stream m a

head :: Monad m => Stream m a -> m (Maybe a)

Unlike head, this function does not diverge if the 'Stream is empty. Instead, Nothing is returned.

last :: Monad m => Stream m a -> m (Maybe a)

Unlike last, this function does not diverge if the Stream is empty. Instead, Nothing is returned.

tail :: (Functor m, Monad m) => Stream m a -> Stream m a

Unlike tail, this function does not diverge if the Stream is empty. Instead, it is the identity in this case.

init :: (Functor m, Monad m) => Stream m a -> Stream m a

Unlike init, this function does not diverge if the Stream is empty. Instead, it is the identity in this case.

null :: Monad m => Stream m a -> m Bool

length :: Monad m => Stream m a -> m Int

Transformations

map :: Monad m => (a -> b) -> Stream m a -> Stream m b

intersperse :: (Functor m, Monad m) => a -> Stream m a -> Stream m a

Folds

foldl :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b

Left-associative fold.

Note that the direction of the traversal is not defined here.

foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b

Left-associative fold with strict accumulator.

Note that the direction of the traversal is not defined here.

foldr :: (Functor m, Monad m) => (a -> b -> b) -> b -> Stream m a -> m b

Right-associative fold.

Note that the direction of the traversal is not defined here.

foldMap :: (Monoid m, Functor n, Monad n) => (a -> m) -> Stream n a -> n m

foldM :: Monad m => (b -> a -> m b) -> b -> Stream m a -> m b

foldM_ :: Monad m => (b -> a -> m b) -> b -> Stream m a -> m ()

Special folds

concatMap :: (Functor m, Monad m) => (a -> Stream m b) -> Stream m a -> Stream m b

Infinite streams

iterate :: Monad m => (a -> a) -> a -> Stream m a

repeat :: Monad m => a -> Stream m a

replicate :: Monad m => Int -> a -> Stream m a

cycle :: (Functor m, Monad m) => Stream m a -> Stream m a

Unlike cycle, this function does not diverge if the Stream is empty. Instead, it is the identity in this case.

Unfolding

unfoldr :: Monad m => (b -> Maybe (a, b)) -> b -> Stream m a

unfoldrM :: (Functor m, Monad m) => (b -> Maybe (a, m b)) -> m b -> Stream m a

Build a stream from a monadic seed (or state function).

Searching streams

filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

Substreams

take :: (Functor m, Monad m) => Int -> Stream m a -> Stream m a

drop :: (Functor m, Monad m) => Int -> Stream m a -> Stream m a

takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a

dropWhile :: (Functor m, Monad m) => (a -> Bool) -> Stream m a -> Stream m a

Zipping and unzipping

zip :: (Functor m, Applicative m, Monad m) => Stream m a -> Stream m b -> Stream m (a, b)

zipWith :: (Functor m, Applicative m, Monad m) => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c

unzip :: (Functor m, Monad m) => Stream m (a, b) -> m ([a], [b])