Implement Mut.restream
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 7 Aug 2008 03:33:57 +0000 (03:33 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 7 Aug 2008 03:33:57 +0000 (03:33 +0000)
Data/Vector/MVector.hs
Data/Vector/MVector/Mut.hs

index 45074c6..ac52920 100644 (file)
@@ -18,7 +18,7 @@ module Data.Vector.MVector (
 
   slice, new, newWith, read, write, copy, grow,
   unstream, mstream, munstream,
-  update, reverse, map
+  update, reverse
 ) where
 
 import qualified Data.Vector.Stream      as Stream
@@ -241,15 +241,3 @@ reverse v = reverse_loop 0 (length v - 1)
                                  unsafeWrite v j x
     reverse_loop _ _ = return ()
 
-
-map :: MVector v m a => (a -> a) -> v a -> m ()
-{-# INLINE map #-}
-map f v = map_loop 0
-  where
-    n = length v
-
-    map_loop i | i <= n    = do
-                               x <- read v i
-                               write v i (f x)
-               | otherwise = return ()
-
index 8c7cd1c..7fa060e 100644 (file)
@@ -1,4 +1,4 @@
-{-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE Rank2Types, ScopedTypeVariables #-}
 
 #include "phases.h"
 
@@ -10,7 +10,9 @@ import qualified Data.Vector.MVector as MVector
 import           Data.Vector.MVector ( MVector )
 
 import           Data.Vector.Stream ( Stream )
+import qualified Data.Vector.Stream as Stream
 
+import Control.Monad  ( liftM )
 import Prelude hiding ( reverse, map )
 
 data Mut a = Mut (forall m mv. MVector mv m a => m (mv a))
@@ -27,6 +29,23 @@ unstream :: Stream a -> Mut a
 {-# INLINE_STREAM unstream #-}
 unstream s = Mut (MVector.unstream s)
 
+restream :: (forall m. Monad m => Stream (m a) -> Stream (m a))
+          -> Mut a -> Mut a
+{-# INLINE_STREAM restream #-}
+restream f (Mut p) = Mut (
+  do
+    v <- p
+    MVector.munstream v (f (MVector.mstream v)))
+
+{-# RULES
+
+"restream/restream [Mut]"
+  forall (f :: forall m. Monad m => Stream (m a) -> Stream (m a))
+         (g :: forall m. Monad m => Stream (m a) -> Stream (m a)) p .
+  restream f (restream g p) = restream (f . g) p
+
+ #-}
+
 update :: Mut a -> Stream (Int, a) -> Mut a
 {-# INLINE_STREAM update #-}
 update m s = trans m (\v -> MVector.update v s)
@@ -36,6 +55,6 @@ reverse :: Mut a -> Mut a
 reverse m = trans m (MVector.reverse)
 
 map :: (a -> a) -> Mut a -> Mut a
-{-# INLINE_STREAM map #-}
-map f m = trans m (MVector.map f)
+{-# INLINE map #-}
+map f = restream (Stream.map (liftM f))