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


-- | Effectful streaming library based on shortcut fusion techniques
--   
@package fusion
@version 0.2.0

module Fusion

-- | A simple stepper, as suggested by Duncan Coutts in his Thesis paper,
--   "Stream Fusion: Practical shortcut fusion for coinductive sequence
--   types". This version adds a result type.
data Step s a r
Done :: r -> Step s a r
Skip :: s -> Step s a r
Yield :: s -> a -> Step s a r
newtype StepList s r a
StepList :: Step s a r -> StepList s r a
getStepList :: StepList s r a -> Step s a r
data Stream a m r
Stream :: (s -> m (Step s a r)) -> s -> Stream a m r

-- | Map over the values produced by a stream.
--   
--   <pre>
--   &gt;&gt;&gt; map (+1) (fromList [1..3]) :: Stream Int Identity ()
--   Stream [2,3,4]
--   </pre>
map :: Functor m => (a -> b) -> Stream a m r -> Stream b m r
filter :: Functor m => (a -> Bool) -> Stream a m r -> Stream a m r
drop :: Applicative m => Int -> Stream a m r -> Stream a m ()
concat :: Monad m => Stream (Stream a m r) m r -> Stream a m r
fromList :: (Foldable f, Applicative m) => f a -> Stream a m ()
fromListM :: (Applicative m, Foldable f) => m (f a) -> Stream a m ()
runStream :: Monad m => Stream a m r -> m r
runStream' :: Monad m => Stream Void m r -> m r

-- | Helper function for more easily writing step functions. Be aware that
--   this can degrade performance over writing the step function directly
--   as an inlined, inner function. The same applies for
--   <a>applyStream</a>, <a>stepStream</a>, <a>foldlStream</a>, etc.
bindStream :: Monad m => (forall s. Step s a r -> m r) -> Stream a m r -> m r
applyStream :: Functor m => (forall s. Step s a r -> r) -> Stream a m r -> m r
stepStream :: Functor m => (forall s. Step s a r -> Step s b r) -> Stream a m r -> Stream b m r
foldlStream :: Monad m => (b -> a -> b) -> (b -> r -> s) -> b -> Stream a m r -> m s
foldlStreamM :: Monad m => (m b -> a -> m b) -> (m b -> r -> m s) -> m b -> Stream a m r -> m s
foldrStream :: Monad m => (a -> b -> b) -> (r -> b) -> Stream a m r -> m b
foldrStreamM :: Monad m => (a -> m b -> m b) -> (r -> m b) -> Stream a m r -> m b
lazyFoldrStreamIO :: (a -> IO b -> IO b) -> (r -> IO b) -> Stream a IO r -> IO b
toList :: Monad m => Stream a m r -> m [a]
lazyToListIO :: Stream a IO r -> IO [a]
emptyStream :: (Monad m, Applicative m) => Stream Void m ()
bracket :: (Monad m, MonadMask (Base m), MonadSafe m) => Base m s -> (s -> Base m ()) -> (forall r. s -> (s -> a -> m r) -> (s -> m r) -> m r -> m r) -> Stream a m ()
next :: Monad m => Stream a m r -> m (Either r (a, Stream a m r))
newtype ListT m a
ListT :: Stream a m () -> ListT m a
getListT :: ListT m a -> Stream a m ()
concatL :: (Monad m, Applicative m) => ListT m (ListT m a) -> ListT m a
type Producer b m r = Stream b m r
type Pipe a b m r = Stream a m () -> Stream b m r
type Consumer a m r = Stream a m () -> m r
each :: (Applicative m, Foldable f) => f a -> Producer a m ()
(>->) :: Stream a m r -> (Stream a m r -> Stream b m r) -> Stream b m r
instance Functor (Step s a)
instance (Monad m, Applicative m) => Monad (ListT m)
instance (Monad m, Applicative m) => Applicative (ListT m)
instance Functor m => Functor (ListT m)
instance MonadTrans (Stream a)
instance (Monad m, Applicative m) => Applicative (Stream a m)
instance Functor m => Functor (Stream a m)
instance Show a => Show (Stream a Identity r)
instance Functor (StepList s r)