Fusion.MStream -> Fusion.Stream.Monadic
[darcs-mirrors/vector.git] / Data / Vector / Fusion / Stream / Monadic.hs
similarity index 66%
rename from Data/Vector/Fusion/MStream.hs
rename to Data/Vector/Fusion/Stream/Monadic.hs
index 726b437..d00439d 100644 (file)
@@ -2,8 +2,8 @@
 
 #include "phases.h"
 
-module Data.Vector.Fusion.MStream (
-  MStream,
+module Data.Vector.Fusion.Stream.Monadic (
+  Stream,
 
   sized,
 
@@ -18,15 +18,15 @@ import Data.Vector.Fusion.Stream.Size
 import Control.Monad  ( liftM )
 import Prelude hiding ( map, mapM, filter )
 
-data MStream m a = forall s. MStream (s -> m (Step s a)) s Size
+data Stream m a = forall s. Stream (s -> m (Step s a)) s Size
 
-sized :: MStream m a -> Size -> MStream m a
+sized :: Stream m a -> Size -> Stream m a
 {-# INLINE_STREAM sized #-}
-sized (MStream step s _) sz = MStream step s sz
+sized (Stream step s _) sz = Stream step s sz
 
-unfoldM :: Monad m => (s -> m (Maybe (a, s))) -> s -> MStream m a
+unfoldM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
 {-# INLINE_STREAM unfoldM #-}
-unfoldM f s = MStream step s Unknown
+unfoldM f s = Stream step s Unknown
   where
     {-# INLINE step #-}
     step s = do
@@ -35,13 +35,13 @@ unfoldM f s = MStream step s Unknown
                  Just (x, s') -> return $ Yield x s'
                  Nothing      -> return $ Done
 
-map :: Monad m => (a -> b) -> MStream m a -> MStream m b
+map :: Monad m => (a -> b) -> Stream m a -> Stream m b
 {-# INLINE map #-}
 map f = mapM (return . f)
 
-mapM :: Monad m => (a -> m b) -> MStream m a -> MStream m b
+mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
 {-# INLINE_STREAM mapM #-}
-mapM f (MStream step s n) = MStream step' s n
+mapM f (Stream step s n) = Stream step' s n
   where
     {-# INLINE step' #-}
     step' s = do
@@ -51,13 +51,13 @@ mapM f (MStream step s n) = MStream step' s n
                   Skip    s' -> return (Skip    s')
                   Done       -> return Done
 
-filter :: Monad m => (a -> Bool) -> MStream m a -> MStream m a
+filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
 {-# INLINE filter #-}
 filter f = filterM (return . f)
 
-filterM :: Monad m => (a -> m Bool) -> MStream m a -> MStream m a
+filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
 {-# INLINE_STREAM filterM #-}
-filterM f (MStream step s n) = MStream step' s (toMax n)
+filterM f (Stream step s n) = Stream step' s (toMax n)
   where
     {-# INLINE step' #-}
     step' s = do
@@ -70,17 +70,17 @@ filterM f (MStream step s n) = MStream step' s (toMax n)
                   Skip    s' -> return $ Skip s'
                   Done       -> return $ Done
 
-foldl :: Monad m => (a -> b -> a) -> a -> MStream m b -> m a
+foldl :: Monad m => (a -> b -> a) -> a -> Stream m b -> m a
 {-# INLINE foldl #-}
 foldl f = foldM (\a b -> return (f a b))
 
-foldr :: Monad m => (a -> b -> b) -> b -> MStream m a -> m b
+foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
 {-# INLINE foldr #-}
 foldr f = foldrM (\a b -> return (f a b))
 
-foldlM :: Monad m => (a -> b -> m a) -> a -> MStream m b -> m a
+foldlM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
 {-# INLINE_STREAM foldlM #-}
-foldlM m z (MStream step s _) = foldlM_go z s
+foldlM m z (Stream step s _) = foldlM_go z s
   where
     foldlM_go z s = do
                       r <- step s
@@ -89,9 +89,9 @@ foldlM m z (MStream step s _) = foldlM_go z s
                         Skip    s' -> foldlM_go z s'
                         Done       -> return z
 
-foldlM' :: Monad m => (a -> b -> m a) -> a -> MStream m b -> m a
+foldlM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
 {-# INLINE_STREAM foldlM' #-}
-foldlM' m z (MStream step s _) = foldlM'_go z s
+foldlM' m z (Stream step s _) = foldlM'_go z s
   where
     foldlM'_go z s = z `seq`
                      do
@@ -101,17 +101,17 @@ foldlM' m z (MStream step s _) = foldlM'_go z s
                          Skip    s' -> foldlM'_go z s'
                          Done       -> return z
 
-foldM :: Monad m => (a -> b -> m a) -> a -> MStream m b -> m a
+foldM :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
 {-# INLINE foldM #-}
 foldM = foldlM
 
-foldM' :: Monad m => (a -> b -> m a) -> a -> MStream m b -> m a
+foldM' :: Monad m => (a -> b -> m a) -> a -> Stream m b -> m a
 {-# INLINE foldM' #-}
 foldM' = foldlM'
 
-foldrM :: Monad m => (a -> b -> m b) -> b -> MStream m a -> m b
+foldrM :: Monad m => (a -> b -> m b) -> b -> Stream m a -> m b
 {-# INLINE_STREAM foldrM #-}
-foldrM f z (MStream step s _) = foldrM_go s
+foldrM f z (Stream step s _) = foldrM_go s
   where
     foldrM_go s = do
                     r <- step s