Merge pull request #48 from ondrap/master

* Fix performance problem with `S.concat`.
* Define a custom `*>`.

Author: treeowl

src/Streaming/Internal.hs

@@ -231,12 +231,8 @@ instance (Functor f, Monad m) => Functor (Stream f m) where
 instance (Functor f, Monad m) => Monad (Stream f m) where
   return = Return
   {-# INLINE return #-}
-  stream1 >> stream2 = loop stream1 where
-    loop stream = case stream of
-      Return _ -> stream2
-      Effect m  -> Effect (fmap loop m)
-      Step f   -> Step (fmap loop f)  
-  {-# INLINABLE (>>) #-}
+  (>>) = (*>)
+  {-# INLINE (>>) #-}
   -- (>>=) = _bind
   -- {-#INLINE (>>=) #-}
   --
@@ -281,6 +277,13 @@ instance (Functor f, Monad m) => Applicative (Stream f m) where
   {-# INLINE pure #-}
   streamf <*> streamx = do {f <- streamf; x <- streamx; return (f x)} 
   {-# INLINE (<*>) #-}  
+  stream1 *> stream2 = loop stream1 where
+    loop stream = case stream of
+      Return _ -> stream2
+      Effect m  -> Effect (fmap loop m)
+      Step f   -> Step (fmap loop f)
+  {-# INLINABLE (*>) #-}
+
 
 {- | The 'Alternative' instance glues streams together stepwise.
 

src/Streaming/Prelude.hs

@@ -557,8 +557,18 @@ chain f = loop where
 -}
 
 concat :: (Monad m, Foldable.Foldable f) => Stream (Of (f a)) m r -> Stream (Of a) m r
-concat str = for str each
-{-# INLINE concat #-}
+concat = loop
+  where
+    loop str = case str of
+        Return r -> Return r
+        Effect m -> Effect (fmap loop m)
+        Step (lst :> as) ->
+          let inner [] = loop as
+              inner (x:rest) = Step (x :> inner rest)
+          in inner (Foldable.toList lst)
+{-# INLINABLE concat #-}
+-- The above hand-written loop is ~20% faster than the 'for' implementation
+-- concat str = for str each
 
 {-| The natural @cons@ for a @Stream (Of a)@.