Fusion.MStream -> Fusion.Stream.Monadic
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 8 Aug 2008 07:06:17 +0000 (07:06 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 8 Aug 2008 07:06:17 +0000 (07:06 +0000)
Data/Vector/Fusion/Stream.hs
Data/Vector/Fusion/Stream/Monadic.hs [moved from Data/Vector/Fusion/MStream.hs with 66% similarity]
Data/Vector/IVector.hs
Data/Vector/MVector.hs
Data/Vector/MVector/New.hs
vector.cabal

index 2be7c96..13b333b 100644 (file)
@@ -16,7 +16,7 @@
 
 module Data.Vector.Fusion.Stream (
   -- * Types
-  Step(..), Stream(..),
+  Step(..), Stream(..), MStream,
 
   -- * Size hints
   size, sized,
@@ -57,6 +57,7 @@ module Data.Vector.Fusion.Stream (
 
 import Data.Vector.Fusion.Stream.Size
 import Data.Vector.Fusion.Stream.Step
+import qualified Data.Vector.Fusion.Stream.Monadic as Monadic
 
 import Prelude hiding ( length, null,
                         replicate, (++),
@@ -72,6 +73,8 @@ import Prelude hiding ( length, null,
 -- | The type of fusible streams
 data Stream a = forall s. Stream (s -> Step s a) s Size
 
+type MStream = Monadic.Stream
+
 -- | 'Size' hint of a 'Stream'
 size :: Stream a -> Size
 {-# INLINE size #-}
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
index ce8fd99..4815ada 100644 (file)
@@ -71,9 +71,8 @@ import qualified Data.Vector.MVector.New as New
 import           Data.Vector.MVector.New ( New )
 
 import qualified Data.Vector.Fusion.Stream as Stream
-import           Data.Vector.Fusion.Stream ( Stream )
-import qualified Data.Vector.Fusion.MStream as MStream
-import           Data.Vector.Fusion.MStream ( MStream )
+import           Data.Vector.Fusion.Stream ( Stream, MStream )
+import qualified Data.Vector.Fusion.Stream.Monadic as MStream
 import           Data.Vector.Fusion.Stream.Size
 
 import Control.Exception ( assert )
@@ -163,12 +162,14 @@ inplace f _ s = f s
 {-# RULES
 
 "inplace [IVector]"
-  forall f (mf :: forall m. Monad m => MStream m a -> MStream m a) m.
+  forall (mf :: forall m. Monad m => MStream m a -> MStream m a)
+         f m.
   New.unstream (inplace f mf (stream (new m))) = New.inplace mf m
 
 "inplace/inplace [IVector]"
   forall f (mf :: forall m. Monad m => MStream m a -> MStream m a)
-         g (mg :: forall m. Monad m => MStream m a -> MStream m a) s.
+         g (mg :: forall m. Monad m => MStream m a -> MStream m a)
+         s.
   inplace f mf (inplace g mg s) = inplace (f . g) (mf . mg) s
 
  #-}
index fa06a4c..5b3ce16 100644 (file)
@@ -22,9 +22,8 @@ module Data.Vector.MVector (
 ) where
 
 import qualified Data.Vector.Fusion.Stream      as Stream
-import           Data.Vector.Fusion.Stream      ( Stream )
-import qualified Data.Vector.Fusion.MStream     as MStream
-import           Data.Vector.Fusion.MStream     ( MStream )
+import           Data.Vector.Fusion.Stream      ( Stream, MStream )
+import qualified Data.Vector.Fusion.Stream.Monadic as MStream
 import           Data.Vector.Fusion.Stream.Size
 
 import Control.Monad.ST ( ST )
index 47488cb..91ed779 100644 (file)
@@ -9,11 +9,10 @@ module Data.Vector.MVector.New (
 import qualified Data.Vector.MVector as MVector
 import           Data.Vector.MVector ( MVector )
 
-import           Data.Vector.Fusion.Stream ( Stream )
+import           Data.Vector.Fusion.Stream ( Stream, MStream )
 import qualified Data.Vector.Fusion.Stream as Stream
 
-import           Data.Vector.Fusion.MStream ( MStream )
-import qualified Data.Vector.Fusion.MStream as MStream
+import qualified Data.Vector.Fusion.Stream.Monadic as MStream
 
 import Control.Monad  ( liftM )
 import Prelude hiding ( reverse, map, filter )
@@ -43,7 +42,8 @@ inplace f (New p) = New (
 
 "inplace/inplace [New]"
   forall (f :: forall m. Monad m => MStream m a -> MStream m a)
-         (g :: forall m. Monad m => MStream m a -> MStream m a) p .
+         (g :: forall m. Monad m => MStream m a -> MStream m a)
+         p .
   inplace f (inplace g p) = inplace (f . g) p
 
  #-}
index ac45cb5..a9433cc 100644 (file)
@@ -24,8 +24,8 @@ Library
   Exposed-Modules:
         Data.Vector.Fusion.Stream.Size
         Data.Vector.Fusion.Stream.Step
+        Data.Vector.Fusion.Stream.Monadic
         Data.Vector.Fusion.Stream
-        Data.Vector.Fusion.MStream
 
         Data.Vector.MVector
         Data.Vector.MVector.New