MVector.Mut -> MVector.New
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 8 Aug 2008 03:40:10 +0000 (03:40 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Fri, 8 Aug 2008 03:40:10 +0000 (03:40 +0000)
Data/Vector/IVector.hs
Data/Vector/MVector/New.hs [moved from Data/Vector/MVector/Mut.hs with 64% similarity]
vector.cabal

index d8b9d39..23e8c76 100644 (file)
@@ -67,8 +67,8 @@ module Data.Vector.IVector (
 import qualified Data.Vector.MVector as MVector
 import           Data.Vector.MVector ( MVector )
 
-import qualified Data.Vector.MVector.Mut as Mut
-import           Data.Vector.MVector.Mut ( Mut )
+import qualified Data.Vector.MVector.New as New
+import           Data.Vector.MVector.New ( New )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Stream )
@@ -124,9 +124,9 @@ class IVector v a where
 -- ------
 
 -- | Construct a pure vector from a monadic initialiser 
-new :: IVector v a => Mut a -> v a
+new :: IVector v a => New a -> v a
 {-# INLINE_STREAM new #-}
-new m = vnew (Mut.run m)
+new m = vnew (New.run m)
 
 -- | Convert a vector to a 'Stream'
 stream :: IVector v a => v a -> Stream a
@@ -142,15 +142,15 @@ stream v = v `seq` (Stream.unfold get 0 `Stream.sized` Exact n)
 -- | Create a vector from a 'Stream'
 unstream :: IVector v a => Stream a -> v a
 {-# INLINE unstream #-}
-unstream s = new (Mut.unstream s)
+unstream s = new (New.unstream s)
 
 {-# RULES
 
 "stream/unstream [IVector]" forall s.
-  stream (new (Mut.unstream s)) = s
+  stream (new (New.unstream s)) = s
 
-"Mut.unstream/stream/new [IVector]" forall p.
-  Mut.unstream (stream (new p)) = p
+"New.unstream/stream/new [IVector]" forall p.
+  New.unstream (stream (new p)) = p
 
  #-}
 
@@ -164,7 +164,7 @@ inplace f _ s = f s
 
 "inplace [IVector]"
   forall f (mf :: forall m. Monad m => MStream m a -> MStream m a) m.
-  Mut.unstream (inplace f mf (stream (new m))) = Mut.inplace mf 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)
@@ -183,7 +183,7 @@ length v = vlength v
 {-# RULES
 
 "length/unstream [IVector]" forall s.
-  length (new (Mut.unstream s)) = Stream.length s
+  length (new (New.unstream s)) = Stream.length s
 
   #-}
 
@@ -243,13 +243,13 @@ last v = v ! (length v - 1)
 {-# RULES
 
 "(!)/unstream [IVector]" forall i s.
-  new (Mut.unstream s) ! i = s Stream.!! i
+  new (New.unstream s) ! i = s Stream.!! i
 
 "head/unstream [IVector]" forall s.
-  head (new (Mut.unstream s)) = Stream.head s
+  head (new (New.unstream s)) = Stream.head s
 
 "last/unstream [IVector]" forall s.
-  last (new (Mut.unstream s)) = Stream.last s
+  last (new (New.unstream s)) = Stream.last s
 
  #-}
 
@@ -295,13 +295,13 @@ drop n = unstream . Stream.drop n . stream
 {-# RULES
 
 "slice/extract [IVector]" forall i n s.
-  slice (new (Mut.unstream s)) i n = extract (new (Mut.unstream s)) i n
+  slice (new (New.unstream s)) i n = extract (new (New.unstream s)) i n
 
 "takeSlice/unstream [IVector]" forall n s.
-  takeSlice n (new (Mut.unstream s)) = take n (new (Mut.unstream s))
+  takeSlice n (new (New.unstream s)) = take n (new (New.unstream s))
 
 "dropSlice/unstream [IVector]" forall n s.
-  dropSlice n (new (Mut.unstream s)) = drop n (new (Mut.unstream s))
+  dropSlice n (new (New.unstream s)) = drop n (new (New.unstream s))
 
   #-}
 
@@ -310,12 +310,12 @@ drop n = unstream . Stream.drop n . stream
 
 (//) :: IVector v a => v a -> [(Int, a)] -> v a
 {-# INLINE (//) #-}
-v // us = new (Mut.update (Mut.unstream (stream v))
+v // us = new (New.update (New.unstream (stream v))
                           (Stream.fromList us))
 
 update :: (IVector v a, IVector v (Int, a)) => v a -> v (Int, a) -> v a
 {-# INLINE update #-}
-update v w = new (Mut.update (Mut.unstream (stream v)) (stream w))
+update v w = new (New.update (New.unstream (stream v)) (stream w))
 
 bpermute :: (IVector v a, IVector v Int) => v a -> v Int -> v a
 {-# INLINE bpermute #-}
@@ -398,10 +398,10 @@ dropWhile f = unstream . Stream.dropWhile f . stream
 {-# RULES
 
 "takeWhileSlice/unstream" forall f s.
-  takeWhileSlice f (new (Mut.unstream s)) = takeWhile f (new (Mut.unstream s))
+  takeWhileSlice f (new (New.unstream s)) = takeWhile f (new (New.unstream s))
 
 "dropWhileSlice/unstream" forall f s.
-  dropWhileSlice f (new (Mut.unstream s)) = dropWhile f (new (Mut.unstream s))
+  dropWhileSlice f (new (New.unstream s)) = dropWhile f (new (New.unstream s))
 
  #-}
 
similarity index 64%
rename from Data/Vector/MVector/Mut.hs
rename to Data/Vector/MVector/New.hs
index 6d3b8c4..d53d039 100644 (file)
@@ -2,8 +2,8 @@
 
 #include "phases.h"
 
-module Data.Vector.MVector.Mut (
-  Mut(..), run, unstream, inplace, update, reverse, map, filter
+module Data.Vector.MVector.New (
+  New(..), run, unstream, inplace, update, reverse, map, filter
 ) where
 
 import qualified Data.Vector.MVector as MVector
@@ -18,49 +18,49 @@ import qualified Data.Vector.MStream as MStream
 import Control.Monad  ( liftM )
 import Prelude hiding ( reverse, map, filter )
 
-data Mut a = Mut (forall m mv. MVector mv m a => m (mv a))
+data New a = New (forall m mv. MVector mv m a => m (mv a))
 
-run :: MVector mv m a => Mut a -> m (mv a)
+run :: MVector mv m a => New a -> m (mv a)
 {-# INLINE run #-}
-run (Mut p) = p
+run (New p) = p
 
-modify :: Mut a -> (forall m mv. MVector mv m a => mv a -> m ()) -> Mut a
+modify :: New a -> (forall m mv. MVector mv m a => mv a -> m ()) -> New a
 {-# INLINE modify #-}
-modify (Mut p) q = Mut (do { v <- p; q v; return v })
+modify (New p) q = New (do { v <- p; q v; return v })
 
-unstream :: Stream a -> Mut a
+unstream :: Stream a -> New a
 {-# INLINE_STREAM unstream #-}
-unstream s = Mut (MVector.unstream s)
+unstream s = New (MVector.unstream s)
 
-inplace :: (forall m. Monad m => MStream m a -> MStream m a) -> Mut a -> Mut a
+inplace :: (forall m. Monad m => MStream m a -> MStream m a) -> New a -> New a
 {-# INLINE_STREAM inplace #-}
-inplace f (Mut p) = Mut (
+inplace f (New p) = New (
   do
     v <- p
     MVector.munstream v (f (MVector.mstream v)))
 
 {-# RULES
 
-"inplace/inplace [Mut]"
+"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 .
   inplace f (inplace g p) = inplace (f . g) p
 
  #-}
 
-update :: Mut a -> Stream (Int, a) -> Mut a
+update :: New a -> Stream (Int, a) -> New a
 {-# INLINE_STREAM update #-}
 update m s = modify m (\v -> MVector.update v s)
 
-reverse :: Mut a -> Mut a
+reverse :: New a -> New a
 {-# INLINE_STREAM reverse #-}
 reverse m = modify m (MVector.reverse)
 
-map :: (a -> a) -> Mut a -> Mut a
+map :: (a -> a) -> New a -> New a
 {-# INLINE map #-}
 map f = inplace (MStream.map f)
 
-filter :: (a -> Bool) -> Mut a -> Mut a
+filter :: (a -> Bool) -> New a -> New a
 {-# INLINE filter #-}
 filter f = inplace (MStream.filter f)
 
index fd81eb4..e398c55 100644 (file)
@@ -27,7 +27,7 @@ Library
         Data.Vector.MStream
 
         Data.Vector.MVector
-        Data.Vector.MVector.Mut
+        Data.Vector.MVector.New
         Data.Vector.IVector
 
         Data.Vector.Unboxed.Unbox