Mutable.Vector -> MVector everywhere
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 19 Nov 2009 00:22:07 +0000 (00:22 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 19 Nov 2009 00:22:07 +0000 (00:22 +0000)
Data/Vector.hs
Data/Vector/Mutable.hs
Data/Vector/Primitive.hs
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable.hs
Data/Vector/Storable/Mutable.hs

index dffdb6d..11e2f5c 100644 (file)
@@ -13,7 +13,7 @@
 --
 
 module Data.Vector (
-  Vector,
+  Vector, MVector,
 
   -- * Length information
   length, null,
@@ -64,7 +64,7 @@ module Data.Vector (
 ) where
 
 import qualified Data.Vector.Generic as G
-import qualified Data.Vector.Mutable as Mut
+import           Data.Vector.Mutable  ( MVector(..) )
 import           Data.Primitive.Array
 
 import Control.Monad.ST ( runST )
@@ -94,7 +94,7 @@ instance Show a => Show (Vector a) where
 instance G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = runST (do
-                       Mut.Vector i n marr <- init
+                       MVector i n marr <- init
                        arr <- unsafeFreezeArray marr
                        return (Vector i n arr))
 
index 6acaad0..25cf2ca 100644 (file)
 -- Mutable boxed vectors.
 --
 
-module Data.Vector.Mutable ( Vector(..), IOVector, STVector )
+module Data.Vector.Mutable ( MVector(..), IOVector, STVector )
 where
 
 import qualified Data.Vector.Generic.Mutable as G
-import           Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
 import           Data.Primitive.Array
 import           Control.Monad.Primitive ( PrimMonad )
 import           Control.Monad.ST ( ST )
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
-data Vector m a = Vector {-# UNPACK #-} !Int
-                         {-# UNPACK #-} !Int
-                         {-# UNPACK #-} !(MutableArray m a)
+data MVector m a = MVector {-# UNPACK #-} !Int
+                           {-# UNPACK #-} !Int
+                           {-# UNPACK #-} !(MutableArray m a)
 
-type IOVector = Vector IO
-type STVector s = Vector (ST s)
+type IOVector = MVector IO
+type STVector s = MVector (ST s)
 
-instance MVectorPure (Vector m) a where
-  length (Vector _ n _) = n
-  unsafeSlice (Vector i _ arr) j m = Vector (i+j) m arr
+instance G.MVectorPure (MVector m) a where
+  length (MVector _ n _) = n
+  unsafeSlice (MVector i _ arr) j m = MVector (i+j) m arr
 
   {-# INLINE overlaps #-}
-  overlaps (Vector i m arr1) (Vector j n arr2)
+  overlaps (MVector i m arr1) (MVector j n arr2)
     = sameMutableArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
 
-instance PrimMonad m => MVector (Vector m) m a where
+instance PrimMonad m => G.MVector (MVector m) m a where
   {-# INLINE unsafeNew #-}
   unsafeNew n = do
                   arr <- newArray n uninitialised
-                  return (Vector 0 n arr)
+                  return (MVector 0 n arr)
 
   {-# INLINE unsafeNewWith #-}
   unsafeNewWith n x = do
                         arr <- newArray n x
-                        return (Vector 0 n arr)
+                        return (MVector 0 n arr)
 
   {-# INLINE unsafeRead #-}
-  unsafeRead (Vector i _ arr) j = readArray arr (i+j)
+  unsafeRead (MVector i _ arr) j = readArray arr (i+j)
 
   {-# INLINE unsafeWrite #-}
-  unsafeWrite (Vector i _ arr) j x = writeArray arr (i+j) x
+  unsafeWrite (MVector i _ arr) j x = writeArray arr (i+j) x
 
   {-# INLINE clear #-}
   clear v = G.set v uninitialised
index 5ac05a5..e2c422f 100644 (file)
@@ -13,7 +13,7 @@
 --
 
 module Data.Vector.Primitive (
-  Vector, Prim,
+  Vector, MVector(..), Prim,
 
   -- * Length information
   length, null,
@@ -64,7 +64,7 @@ module Data.Vector.Primitive (
 ) where
 
 import qualified Data.Vector.Generic           as G
-import qualified Data.Vector.Primitive.Mutable as Mut
+import           Data.Vector.Primitive.Mutable ( MVector(..) )
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim )
 
@@ -96,7 +96,7 @@ instance (Show a, Prim a) => Show (Vector a) where
 instance Prim a => G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = runST (do
-                       Mut.Vector i n marr <- init
+                       MVector i n marr <- init
                        arr <- unsafeFreezeByteArray marr
                        return (Vector i n arr))
 
index 774fd5f..227fdf3 100644 (file)
 -- Mutable primitive vectors.
 --
 
-module Data.Vector.Primitive.Mutable ( Vector(..), IOVector, STVector )
+module Data.Vector.Primitive.Mutable ( MVector(..), IOVector, STVector )
 where
 
-import           Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
+import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
 
 -- | Mutable unboxed vectors. They live in the 'ST' monad.
-data Vector m a = Vector {-# UNPACK #-} !Int
+data MVector m a = MVector {-# UNPACK #-} !Int
                          {-# UNPACK #-} !Int
                          {-# UNPACK #-} !(MutableByteArray m)
 
-type IOVector = Vector IO
-type STVector s = Vector (ST s)
+type IOVector = MVector IO
+type STVector s = MVector (ST s)
 
-instance Prim a => MVectorPure (Vector m) a where
-  length (Vector _ n _) = n
-  unsafeSlice (Vector i _ arr) j m = Vector (i+j) m arr
+instance Prim a => G.MVectorPure (MVector m) a where
+  length (MVector _ n _) = n
+  unsafeSlice (MVector i _ arr) j m = MVector (i+j) m arr
 
   {-# INLINE overlaps #-}
-  overlaps (Vector i m arr1) (Vector j n arr2)
+  overlaps (MVector i m arr1) (MVector j n arr2)
     = sameMutableByteArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
 
-instance (Prim a, PrimMonad m) => MVector (Vector m) m a where
+instance (Prim a, PrimMonad m) => G.MVector (MVector m) m a where
   {-# INLINE unsafeNew #-}
   unsafeNew n = do
                   arr <- newByteArray (n * sizeOf (undefined :: a))
-                  return (Vector 0 n arr)
+                  return (MVector 0 n arr)
 
   {-# INLINE unsafeRead #-}
-  unsafeRead (Vector i _ arr) j = readByteArray arr (i+j)
+  unsafeRead (MVector i _ arr) j = readByteArray arr (i+j)
 
   {-# INLINE unsafeWrite #-}
-  unsafeWrite (Vector i _ arr) j x = writeByteArray arr (i+j) x
+  unsafeWrite (MVector i _ arr) j x = writeByteArray arr (i+j) x
 
   {-# INLINE clear #-}
   clear _ = return ()
index 608b576..0d035e4 100644 (file)
@@ -13,7 +13,7 @@
 --
 
 module Data.Vector.Storable (
-  Vector, Storable,
+  Vector, MVector(..), Storable,
 
   -- * Length information
   length, null,
@@ -64,7 +64,7 @@ module Data.Vector.Storable (
 ) where
 
 import qualified Data.Vector.Generic          as G
-import qualified Data.Vector.Storable.Mutable as Mut
+import           Data.Vector.Storable.Mutable ( MVector(..) )
 import Data.Vector.Storable.Internal
 
 import Foreign.Storable
@@ -101,7 +101,7 @@ instance (Show a, Storable a) => Show (Vector a) where
 instance Storable a => G.Vector Vector a where
   {-# INLINE vnew #-}
   vnew init = unsafePerformIO (do
-                                 Mut.Vector i n p <- init
+                                 MVector i n p <- init
                                  return (Vector i n p))
 
   {-# INLINE vlength #-}
index 7d134e9..fd1d851 100644 (file)
 -- Mutable vectors based on Storable.
 --
 
-module Data.Vector.Storable.Mutable( Vector(..) )
+module Data.Vector.Storable.Mutable( MVector(..) )
 where
 
-import Data.Vector.Generic.Mutable ( MVector(..), MVectorPure(..) )
+import qualified Data.Vector.Generic.Mutable as G
 
 import Foreign.Storable
 import Foreign.ForeignPtr
 
 -- | Mutable 'Storable'-based vectors in the 'IO' monad.
-data Vector a = Vector {-# UNPACK #-} !Int
+data MVector a = MVector {-# UNPACK #-} !Int
                        {-# UNPACK #-} !Int
                        {-# UNPACK #-} !(ForeignPtr a)
 
-instance MVectorPure Vector a where
+instance G.MVectorPure MVector a where
   {-# INLINE length #-}
-  length (Vector _ n _) = n
+  length (MVector _ n _) = n
 
   {-# INLINE unsafeSlice #-}
-  unsafeSlice (Vector i _ p) j m = Vector (i+j) m p
+  unsafeSlice (MVector i _ p) j m = MVector (i+j) m p
 
   -- FIXME: implement this properly
   {-# INLINE overlaps #-}
-  overlaps (Vector i m p) (Vector j n q)
+  overlaps (MVector i m p) (MVector j n q)
     = True
 
-instance Storable a => MVector Vector IO a where
+instance Storable a => G.MVector MVector IO a where
   {-# INLINE unsafeNew #-}
-  unsafeNew n = Vector 0 n `fmap` mallocForeignPtrArray n
+  unsafeNew n = MVector 0 n `fmap` mallocForeignPtrArray n
 
   {-# INLINE unsafeRead #-}
-  unsafeRead (Vector i n p) j = withForeignPtr p $ \ptr ->
+  unsafeRead (MVector i n p) j = withForeignPtr p $ \ptr ->
                                 peekElemOff ptr (i+j)
      
   {-# INLINE unsafeWrite #-}
-  unsafeWrite (Vector i n p) j x = withForeignPtr p $ \ptr ->
+  unsafeWrite (MVector i n p) j x = withForeignPtr p $ \ptr ->
                                    pokeElemOff ptr (i+j) x 
 
   {-# INLINE clear #-}