Safe Haskell | None |
---|---|
Language | Haskell2010 |
- data Step s a r
- newtype StepList s r a = StepList {
- getStepList :: Step s a r
- data Stream a m r where
- mapS :: Functor m => (a -> b) -> Stream a m r -> Stream b m r
- concatS :: Monad m => Stream (Stream a m r) m r -> Stream a m r
- fromList :: Foldable f => Applicative m => f a -> Stream a m ()
- fromListM :: (Monad m, Foldable f) => m (f a) -> Stream a m ()
- toListS :: Monad m => Stream a m r -> m [a]
- lazyToListS :: Stream a IO r -> IO [a]
- runEffect :: Monad m => Stream a m r -> m r
- emptyStream :: (Monad m, Applicative m) => Stream Void m ()
- bracketS :: (Monad m, MonadMask m, MonadSafe m) => Base m s -> (s -> Base m ()) -> (forall r. s -> (a -> s -> 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 {}
- 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 ()
- mapP :: (Monad m, Applicative m) => (a -> b) -> Pipe a b m ()
Step
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.
StepList
Stream
data Stream a m r where Source
MonadTrans (Stream a) | |
Functor m => Functor (Stream a m) | |
(Monad m, Applicative m) => Applicative (Stream a m) | |
Show a => Show (Stream a Identity r) |
mapS :: Functor m => (a -> b) -> Stream a m r -> Stream b m r Source
Map over the values produced by a stream.
>>>
mapS (+1) (fromList [1..3]) :: Stream Int Identity ()
Stream [2,3,4]
fromList :: Foldable f => Applicative m => f a -> Stream a m () Source
lazyToListS :: Stream a IO r -> IO [a] Source
emptyStream :: (Monad m, Applicative m) => Stream Void m () Source
bracketS :: (Monad m, MonadMask m, MonadSafe m) => Base m s -> (s -> Base m ()) -> (forall r. s -> (a -> s -> m r) -> (s -> m r) -> m r -> m r) -> Stream a m () Source
StreamList
(Monad m, Applicative m) => Monad (ListT m) | |
Functor m => Functor (ListT m) | |
(Monad m, Applicative m) => Applicative (ListT m) |
Pipes
each :: (Applicative m, Foldable f) => f a -> Producer a m () Source
mapP :: (Monad m, Applicative m) => (a -> b) -> Pipe a b m () Source