-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Group streams into substreams
--   
--   pipes-group uses FreeT and lenses to group streams
--   into sub-streams. Notable features include:
--   
--   
--   
- Perfect Streaming: Group elements without collecting them
--   into memory
--   
- Lens Support: Use lenses to simplify many common
--   operations
--   
--   
--   Pipes.Group contains the full documentation for this library.
--   
--   Read Pipes.Group.Tutorial for an extensive tutorial.
@package pipes-group
@version 1.0.3

-- | Element-agnostic grouping utilities for pipes
--   
--   See Pipes.Group.Tutorial for an extended tutorial
module Pipes.Group

-- | groupsBy splits a Producer into a FreeT of
--   Producers grouped using the given equality predicate
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> (toList . intercalates (yield '|') . view (groupsBy (==))) (each "12233345")
--   "1|22|333|4|5"
--   
--   
--   You can think of this as:
--   
--   
--   groupsBy
--       :: Monad m
--       => (a -> a -> Bool) -> Lens' (Producer a m x) (FreeT (Producer a m) m x)
--   
groupsBy :: Monad m => (a' -> a' -> Bool) -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x)

-- | groupsBy' splits a Producer into a FreeT of
--   Producers grouped using the given equality predicate
--   
--   This differs from groupsBy by comparing successive elements for
--   equality instead of comparing each element to the first member of the
--   group
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> let cmp c1 c2 = succ c1 == c2
--   
--   >>> (toList . intercalates (yield '|') . view (groupsBy' cmp)) (each "12233345")
--   "12|23|3|345"
--   
--   >>> (toList . intercalates (yield '|') . view (groupsBy  cmp)) (each "12233345")
--   "122|3|3|34|5"
--   
--   
--   You can think of this as:
--   
--   
--   groupsBy'
--       :: Monad m
--       => (a -> a -> Bool)
--       -> Lens' (Producer a m x) (FreeT (Producer a m) m x)
--   
groupsBy' :: Monad m => (a' -> a' -> Bool) -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x)

-- | Like groupsBy, where the equality predicate is (==)
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> (toList . intercalates (yield '|') . view groups) (each "12233345")
--   "1|22|333|4|5"
--   
--   
--   You can think of this as:
--   
--   
--   groups
--       :: (Monad m, Eq a) => Lens' (Producer a m x) (FreeT (Producer a m) m x)
--   
groups :: (Monad m, Eq a') => Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x)

-- | chunksOf is an splits a Producer into a FreeT of
--   Producers of fixed length
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> (toList . intercalates (yield '|') . view (chunksOf 3)) (each "12233345")
--   "122|333|45"
--   
--   
--   You can think of this as:
--   
--   
--   chunksOf
--       :: Monad m => Int -> Lens' (Producer a m x) (FreeT (Producer a m) m x)
--   
chunksOf :: Monad m => Int -> Lens (Producer a' m x) (Producer a m x) (FreeT (Producer a' m) m x) (FreeT (Producer a m) m x)

-- | (takes n) only keeps the first n functor layers of a
--   FreeT
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> (toList . intercalates (yield '|') . takes 3 . view groups) (each "12233345")
--   "1|22|333"
--   
--   
--   You can think of this as:
--   
--   
--   takes
--       :: (Functor f, Monad m)
--       => Int -> FreeT (Producer a m) m () -> FreeT (Producer a m) m ()
--   
takes :: (Functor f, Monad m) => Int -> FreeT f m () -> FreeT f m ()

-- | (takes' n) only keeps the first n Producers
--   of a FreeT
--   
--   takes' differs from takes by draining unused
--   Producers in order to preserve the return value. This makes it
--   a suitable argument for maps.
takes' :: Monad m => Int -> FreeT (Producer a m) m x -> FreeT (Producer a m) m x

-- | (drops n) peels off the first n Producer
--   layers of a FreeT
--   
--   
--   >>> import Lens.Family (view)
--   
--   >>> import Pipes (yield, each)
--   
--   >>> import Pipes.Prelude (toList)
--   
--   >>> (toList . intercalates (yield '|') . drops 3 . view groups) (each "12233345")
--   "4|5"
--   
--   
--   Use carefully: the peeling off is not free. This runs the first
--   n layers, just discarding everything they produce.
drops :: Monad m => Int -> FreeT (Producer a m) m x -> FreeT (Producer a m) m x

-- | Transform each individual functor layer of a FreeT
--   
--   You can think of this as:
--   
--   
--   maps
--       :: (forall r . Producer a m r -> Producer b m r)
--       -> FreeT (Producer a m) m x -> FreeT (Producer b m) m x
--   
--   
--   This is just a synonym for transFreeT
maps :: (Monad m, Functor g) => (forall r. f r -> g r) -> FreeT f m x -> FreeT g m x

-- | Lens to transform each individual functor layer of a FreeT
--   
--   
--   over individually = maps  -- ... with a less general type
--   
individually :: (Monad m, Functor g) => Setter (FreeT f m x) (FreeT g m x) (f (FreeT f m x)) (g (FreeT f m x))

-- | Join a FreeT-delimited stream of Producers into a single
--   Producer
concats :: Monad m => FreeT (Producer a m) m x -> Producer a m x

-- | Join a FreeT-delimited stream of Producers into a single
--   Producer by intercalating a Producer in between them
intercalates :: Monad m => Producer a m () -> FreeT (Producer a m) m x -> Producer a m x

-- | Fold each Producer of a FreeT
--   
--   
--   purely folds
--       :: Monad m => Fold a b -> FreeT (Producer a m) m r -> Producer b m r
--   
folds :: Monad m => (x -> a -> x) -> x -> (x -> b) -> FreeT (Producer a m) m r -> Producer b m r

-- | Fold each Producer of a FreeT, monadically
--   
--   
--   impurely foldsM
--       :: Monad m => FoldM a b -> FreeT (Producer a m) m r -> Producer b m r
--   
foldsM :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> FreeT (Producer a m) m r -> Producer b m r

-- | pipes-group builds upon pipes to establish idioms
--   for grouping streams into sub-streams without collecting elements into
--   memory. This tutorial assumes familiarity with pipes and
--   pipes-parse.
module Pipes.Group.Tutorial
