Data.Stream.Monadic

Contents

• Conversion with lists
• Basic functions
• Transformations
• Folds
• Special folds
• Building streams
  • Scans
  • Infinite streams
  • Unfolding
• Substreams
  • Extracting substreams
  • Predicates
• Searching streams
  • Searching by equality
  • Searching with a predicate
• Zipping and unzipping
• Special streams
  • "Set" operations
• Generalized functions
  • User-supplied comparison, replacing an Ord context
• The "generic" operations

Description

Synopsis

• data Step a s
  • = Yield a !s
  • | Skip !s
  • | Done
• data Stream m a = Stream (s -> m (Step a s)) (m s)
• toList :: (Functor m, Monad m) => Stream m a -> m [a]
• fromList :: Monad m => [a] -> Stream m a
• 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)
• last :: Monad m => Stream m a -> m (Maybe a)
• tail :: (Functor m, Monad m) => Stream m a -> Stream m a
• init :: (Functor m, Monad m) => Stream m a -> Stream m a
• null :: Monad m => Stream m a -> m Bool
• length :: Monad m => Stream m a -> m Int
• map :: Monad m => (a -> b) -> Stream m a -> Stream m b
• mapM :: (Functor m, Monad m) => (a -> m b) -> Stream m a -> Stream m b
• mapM_ :: (Functor m, Monad m) => (a -> m b) -> Stream m a -> Stream m ()
• reverse :: (Functor m, Monad m) => Stream m a -> m (Stream m a)
• intersperse :: (Functor m, Monad m) => a -> Stream m a -> Stream m a
• intercalate :: (Functor m, Monad m) => Stream m a -> Stream m [a] -> Stream m a
• foldl :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b
• foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b
• foldr :: (Functor m, Monad m) => (a -> b -> b) -> b -> Stream m a -> m b
• 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 ()
• concat :: (Functor m, Monad m) => Stream m [a] -> Stream m a
• concatMap :: (Functor m, Monad m) => (a -> Stream m b) -> Stream m a -> Stream m b
• and :: (Functor m, Monad m) => Stream m Bool -> m Bool
• or :: (Functor m, Monad m) => Stream m Bool -> m Bool
• any :: Monad m => (a -> Bool) -> Stream m a -> m Bool
• all :: Monad m => (a -> Bool) -> Stream m a -> m Bool
• sum :: (Num a, Monad m) => Stream m a -> m a
• product :: (Num a, Monad m) => Stream m a -> m a
• scanl :: (Functor m, Monad m) => (b -> a -> b) -> b -> Stream m a -> Stream m b
• 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
• 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
• take :: (Functor m, Monad m) => Int -> Stream m a -> Stream m a
• drop :: (Functor m, Monad m) => Int -> Stream m a -> Stream m a
• splitAt :: (Functor m, Monad m) => Int -> Stream m a -> (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
• span :: (Functor m, Monad m) => (a -> Bool) -> Stream m a -> (Stream m a, Stream m a)
• break :: (Functor m, Monad m) => (a -> Bool) -> Stream m a -> (Stream m a, Stream m a)
• isPrefixOf :: (Eq a, Monad m) => Stream m a -> Stream m a -> m Bool
• isSuffixOf :: (Eq a, Functor m, Monad m) => Stream m a -> Stream m a -> m Bool
• elem :: (Eq a, Monad m) => a -> Stream m a -> m Bool
• notElem :: (Eq a, Monad m) => a -> Stream m a -> m Bool
• lookup :: (Eq a, Monad m) => a -> Stream m (a, b) -> m (Maybe b)
• find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a)
• filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
• zip :: (Functor m, Applicative m, Monad m) => Stream m a -> Stream m b -> Stream m (a, b)
• zip3 :: (Functor m, Applicative m, Monad m) => Stream m a -> Stream m b -> Stream m c -> Stream m (a, b, c)
• zip4 :: (Functor m, Applicative m, Monad m) => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m (a, b, c, d)
• zipWith :: (Functor m, Applicative m, Monad m) => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
• zipWith3 :: (Functor m, Applicative m, Monad m) => (a -> b -> c -> d) -> Stream m a -> Stream m b -> Stream m c -> Stream m d
• zipWith4 :: (Functor m, Applicative m, Monad m) => (a -> b -> c -> d -> e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
• unzip :: (Functor m, Monad m) => Stream m (a, b) -> m ([a], [b])
• unzip3 :: (Functor m, Monad m) => Stream m (a, b, c) -> m ([a], [b], [c])
• unzip4 :: (Functor m, Monad m) => Stream m (a, b, c, d) -> m ([a], [b], [c], [d])
• delete :: (Eq a, Functor m, Monad m) => a -> Stream m a -> Stream m a
• insert :: (Ord a, Functor m, Monad m) => a -> Stream m a -> Stream m a
• deleteBy :: (Functor m, Monad m) => (a -> a -> Bool) -> a -> Stream m a -> Stream m a
• insertBy :: (Functor m, Monad m) => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a
• genericLength :: (Num i, Functor m, Monad m) => Stream m a -> m i
• genericTake :: (Integral i, Functor m, Monad m) => i -> Stream m a -> Stream m a
• genericDrop :: (Integral i, Functor m, Monad m) => i -> Stream m a -> Stream m a
• genericSplitAt :: (Integral i, Functor m, Monad m) => i -> Stream m a -> (Stream m a, Stream m a)
• genericReplicate :: (Integral i, Functor m, Monad m) => i -> a -> Stream m a
• enumFromToInt :: Monad m => Int -> Int -> Stream m Int
• enumFromToChar :: Monad m => Char -> Char -> Stream m Char
• enumDeltaInteger :: Monad m => Integer -> Integer -> Stream m Integer

Documentation

Conversion with lists

Basic functions

Transformations

Folds

Special folds

Building streams

Scans

Infinite streams

Unfolding

Substreams

Extracting substreams

splitAt n s = (take n s, drop n s)

Predicates

isSuffixOf a b = reverse a `isPrefixOf` reverse b

Searching streams

Searching by equality

Searching with a predicate

Zipping and unzipping

Special streams

"Set" operations

Generalized functions

User-supplied comparison, replacing an Ord context

The "generic" operations