D.V.Unboxed => D.V.Primitive
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 12 Sep 2009 22:47:12 +0000 (22:47 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 12 Sep 2009 22:47:12 +0000 (22:47 +0000)
Data/Vector/Primitive.hs [moved from Data/Vector/Unboxed.hs with 69% similarity]
Data/Vector/Primitive/Mutable/IO.hs [moved from Data/Vector/Unboxed/Mutable/IO.hs with 77% similarity]
Data/Vector/Primitive/Mutable/ST.hs [moved from Data/Vector/Unboxed/Mutable/ST.hs with 83% similarity]
Data/Vector/Primitive/Prim.hs [moved from Data/Vector/Unboxed/Unbox.hs with 87% similarity]
vector.cabal

similarity index 69%
rename from Data/Vector/Unboxed.hs
rename to Data/Vector/Primitive.hs
index c8dc272..0adecb4 100644 (file)
@@ -1,7 +1,7 @@
 {-# LANGUAGE MagicHash, UnboxedTuples, FlexibleInstances, MultiParamTypeClasses #-}
 
 -- |
--- Module      : Data.Vector.Unboxed
+-- Module      : Data.Vector.Primitive
 -- Copyright   : (c) Roman Leshchinskiy 2008
 -- License     : BSD-style
 --
@@ -9,10 +9,10 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Unboxed vectors based on 'Unbox'.
+-- Unboxed vectors of primitive types.
 --
 
-module Data.Vector.Unboxed (
+module Data.Vector.Primitive (
   Vector,
 
   -- * Length information
@@ -65,8 +65,8 @@ module Data.Vector.Unboxed (
 
 import           Data.Vector.IVector ( IVector(..) )
 import qualified Data.Vector.IVector            as IV
-import qualified Data.Vector.Unboxed.Mutable.ST as Mut
-import           Data.Vector.Unboxed.Unbox
+import qualified Data.Vector.Primitive.Mutable.ST as Mut
+import           Data.Vector.Primitive.Prim
 
 import Control.Monad.ST ( runST )
 
@@ -89,15 +89,15 @@ import Prelude hiding ( length, null,
 
 import qualified Prelude
 
--- | Unboxed vectors
+-- | Unboxed vectors of primitive types
 data Vector a = Vector {-# UNPACK #-} !Int
                        {-# UNPACK #-} !Int
                                       ByteArray#
 
-instance (Show a, Unbox a) => Show (Vector a) where
-    show = (Prelude.++ " :: Data.Vector.Unboxed.Vector") . ("fromList " Prelude.++) . show . toList
+instance (Show a, Prim a) => Show (Vector a) where
+    show = (Prelude.++ " :: Data.Vector.Primitive.Vector") . ("fromList " Prelude.++) . show . toList
 
-instance Unbox a => IVector Vector a where
+instance Prim a => IVector Vector a where
   {-# INLINE vnew #-}
   vnew init = runST (do
                        Mut.Vector i n marr# <- init
@@ -113,22 +113,22 @@ instance Unbox a => IVector Vector a where
   {-# INLINE unsafeIndexM #-}
   unsafeIndexM (Vector (I# i#) _ arr#) (I# j#) = return (at# arr# (i# +# j#))
 
-instance (Unbox a, Eq a) => Eq (Vector a) where
+instance (Prim a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
   (==) = IV.eq
 
-instance (Unbox a, Ord a) => Ord (Vector a) where
+instance (Prim a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
   compare = IV.cmp
 
 -- Length
 -- ------
 
-length :: Unbox a => Vector a -> Int
+length :: Prim a => Vector a -> Int
 {-# INLINE length #-}
 length = IV.length
 
-null :: Unbox a => Vector a -> Bool
+null :: Prim a => Vector a -> Bool
 {-# INLINE null #-}
 null = IV.null
 
@@ -136,38 +136,38 @@ null = IV.null
 -- ------------
 
 -- | Empty vector
-empty :: Unbox a => Vector a
+empty :: Prim a => Vector a
 {-# INLINE empty #-}
 empty = IV.empty
 
 -- | Vector with exaclty one element
-singleton :: Unbox a => a -> Vector a
+singleton :: Prim a => a -> Vector a
 {-# INLINE singleton #-}
 singleton = IV.singleton
 
 -- | Vector of the given length with the given value in each position
-replicate :: Unbox a => Int -> a -> Vector a
+replicate :: Prim a => Int -> a -> Vector a
 {-# INLINE replicate #-}
 replicate = IV.replicate
 
 -- | Prepend an element
-cons :: Unbox a => a -> Vector a -> Vector a
+cons :: Prim a => a -> Vector a -> Vector a
 {-# INLINE cons #-}
 cons = IV.cons
 
 -- | Append an element
-snoc :: Unbox a => Vector a -> a -> Vector a
+snoc :: Prim a => Vector a -> a -> Vector a
 {-# INLINE snoc #-}
 snoc = IV.snoc
 
 infixr 5 ++
 -- | Concatenate two vectors
-(++) :: Unbox a => Vector a -> Vector a -> Vector a
+(++) :: Prim a => Vector a -> Vector a -> Vector a
 {-# INLINE (++) #-}
 (++) = (IV.++)
 
 -- | Create a copy of a vector. Useful when dealing with slices.
-copy :: Unbox a => Vector a -> Vector a
+copy :: Prim a => Vector a -> Vector a
 {-# INLINE copy #-}
 copy = IV.copy
 
@@ -175,17 +175,17 @@ copy = IV.copy
 -- -----------------------------
 
 -- | Indexing
-(!) :: Unbox a => Vector a -> Int -> a
+(!) :: Prim a => Vector a -> Int -> a
 {-# INLINE (!) #-}
 (!) = (IV.!)
 
 -- | First element
-head :: Unbox a => Vector a -> a
+head :: Prim a => Vector a -> a
 {-# INLINE head #-}
 head = IV.head
 
 -- | Last element
-last :: Unbox a => Vector a -> a
+last :: Prim a => Vector a -> a
 {-# INLINE last #-}
 last = IV.last
 
@@ -194,48 +194,48 @@ last = IV.last
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'unsafeSlice'.
-slice :: Unbox a => Vector a -> Int   -- ^ starting index
+slice :: Prim a => Vector a -> Int   -- ^ starting index
                              -> Int   -- ^ length
                              -> Vector a
 {-# INLINE slice #-}
 slice = IV.slice
 
 -- | Yield all but the last element without copying.
-init :: Unbox a => Vector a -> Vector a
+init :: Prim a => Vector a -> Vector a
 {-# INLINE init #-}
 init = IV.init
 
 -- | All but the first element (without copying).
-tail :: Unbox a => Vector a -> Vector a
+tail :: Prim a => Vector a -> Vector a
 {-# INLINE tail #-}
 tail = IV.tail
 
 -- | Yield the first @n@ elements without copying.
-take :: Unbox a => Int -> Vector a -> Vector a
+take :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE take #-}
 take = IV.take
 
 -- | Yield all but the first @n@ elements without copying.
-drop :: Unbox a => Int -> Vector a -> Vector a
+drop :: Prim a => Int -> Vector a -> Vector a
 {-# INLINE drop #-}
 drop = IV.drop
 
 -- Permutations
 -- ------------
 
-accum :: Unbox a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
+accum :: Prim a => (a -> b -> a) -> Vector a -> [(Int,b)] -> Vector a
 {-# INLINE accum #-}
 accum = IV.accum
 
-(//) :: Unbox a => Vector a -> [(Int, a)] -> Vector a
+(//) :: Prim a => Vector a -> [(Int, a)] -> Vector a
 {-# INLINE (//) #-}
 (//) = (IV.//)
 
-backpermute :: Unbox a => Vector a -> Vector Int -> Vector a
+backpermute :: Prim a => Vector a -> Vector Int -> Vector a
 {-# INLINE backpermute #-}
 backpermute = IV.backpermute
 
-reverse :: Unbox a => Vector a -> Vector a
+reverse :: Prim a => Vector a -> Vector a
 {-# INLINE reverse #-}
 reverse = IV.reverse
 
@@ -243,11 +243,11 @@ reverse = IV.reverse
 -- -------
 
 -- | Map a function over a vector
-map :: (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
+map :: (Prim a, Prim b) => (a -> b) -> Vector a -> Vector b
 {-# INLINE map #-}
 map = IV.map
 
-concatMap :: (Unbox a, Unbox b) => (a -> Vector b) -> Vector a -> Vector b
+concatMap :: (Prim a, Prim b) => (a -> Vector b) -> Vector a -> Vector b
 {-# INLINE concatMap #-}
 concatMap = IV.concatMap
 
@@ -255,13 +255,13 @@ concatMap = IV.concatMap
 -- -----------------
 
 -- | Zip two vectors with the given function.
-zipWith :: (Unbox a, Unbox b, Unbox c)
+zipWith :: (Prim a, Prim b, Prim c)
         => (a -> b -> c) -> Vector a -> Vector b -> Vector c
 {-# INLINE zipWith #-}
 zipWith = IV.zipWith
 
 -- | Zip three vectors with the given function.
-zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d)
+zipWith3 :: (Prim a, Prim b, Prim c, Prim d)
          => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
 {-# INLINE zipWith3 #-}
 zipWith3 = IV.zipWith3
@@ -270,17 +270,17 @@ zipWith3 = IV.zipWith3
 -- ---------
 
 -- | Drop elements which do not satisfy the predicate
-filter :: Unbox a => (a -> Bool) -> Vector a -> Vector a
+filter :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE filter #-}
 filter = IV.filter
 
 -- | Yield the longest prefix of elements satisfying the predicate.
-takeWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
+takeWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE takeWhile #-}
 takeWhile = IV.takeWhile
 
 -- | Drop the longest prefix of elements that satisfy the predicate.
-dropWhile :: Unbox a => (a -> Bool) -> Vector a -> Vector a
+dropWhile :: Prim a => (a -> Bool) -> Vector a -> Vector a
 {-# INLINE dropWhile #-}
 dropWhile = IV.dropWhile
 
@@ -289,25 +289,25 @@ dropWhile = IV.dropWhile
 
 infix 4 `elem`
 -- | Check whether the vector contains an element
-elem :: (Unbox a, Eq a) => a -> Vector a -> Bool
+elem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE elem #-}
 elem = IV.elem
 
 infix 4 `notElem`
 -- | Inverse of `elem`
-notElem :: (Unbox a, Eq a) => a -> Vector a -> Bool
+notElem :: (Prim a, Eq a) => a -> Vector a -> Bool
 {-# INLINE notElem #-}
 notElem = IV.notElem
 
 -- | Yield 'Just' the first element matching the predicate or 'Nothing' if no
 -- such element exists.
-find :: Unbox a => (a -> Bool) -> Vector a -> Maybe a
+find :: Prim a => (a -> Bool) -> Vector a -> Maybe a
 {-# INLINE find #-}
 find = IV.find
 
 -- | Yield 'Just' the index of the first element matching the predicate or
 -- 'Nothing' if no such element exists.
-findIndex :: Unbox a => (a -> Bool) -> Vector a -> Maybe Int
+findIndex :: Prim a => (a -> Bool) -> Vector a -> Maybe Int
 {-# INLINE findIndex #-}
 findIndex = IV.findIndex
 
@@ -315,32 +315,32 @@ findIndex = IV.findIndex
 -- -------
 
 -- | Left fold
-foldl :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
+foldl :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl #-}
 foldl = IV.foldl
 
 -- | Lefgt fold on non-empty vectors
-foldl1 :: Unbox a => (a -> a -> a) -> Vector a -> a
+foldl1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1 #-}
 foldl1 = IV.foldl1
 
 -- | Left fold with strict accumulator
-foldl' :: Unbox b => (a -> b -> a) -> a -> Vector b -> a
+foldl' :: Prim b => (a -> b -> a) -> a -> Vector b -> a
 {-# INLINE foldl' #-}
 foldl' = IV.foldl'
 
 -- | Left fold on non-empty vectors with strict accumulator
-foldl1' :: Unbox a => (a -> a -> a) -> Vector a -> a
+foldl1' :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldl1' #-}
 foldl1' = IV.foldl1'
 
 -- | Right fold
-foldr :: Unbox a => (a -> b -> b) -> b -> Vector a -> b
+foldr :: Prim a => (a -> b -> b) -> b -> Vector a -> b
 {-# INLINE foldr #-}
 foldr = IV.foldr
 
 -- | Right fold on non-empty vectors
-foldr1 :: Unbox a => (a -> a -> a) -> Vector a -> a
+foldr1 :: Prim a => (a -> a -> a) -> Vector a -> a
 {-# INLINE foldr1 #-}
 foldr1 = IV.foldr1
 
@@ -357,26 +357,26 @@ or :: Vector Bool -> Bool
 or = IV.or
 -}
 
-sum :: (Unbox a, Num a) => Vector a -> a
+sum :: (Prim a, Num a) => Vector a -> a
 {-# INLINE sum #-}
 sum = IV.sum
 
-product :: (Unbox a, Num a) => Vector a -> a
+product :: (Prim a, Num a) => Vector a -> a
 {-# INLINE product #-}
 product = IV.product
 
-maximum :: (Unbox a, Ord a) => Vector a -> a
+maximum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE maximum #-}
 maximum = IV.maximum
 
-minimum :: (Unbox a, Ord a) => Vector a -> a
+minimum :: (Prim a, Ord a) => Vector a -> a
 {-# INLINE minimum #-}
 minimum = IV.minimum
 
 -- Unfolding
 -- ---------
 
-unfoldr :: Unbox a => (b -> Maybe (a, b)) -> b -> Vector a
+unfoldr :: Prim a => (b -> Maybe (a, b)) -> b -> Vector a
 {-# INLINE unfoldr #-}
 unfoldr = IV.unfoldr
 
@@ -384,53 +384,53 @@ unfoldr = IV.unfoldr
 -- -----
 
 -- | Prefix scan
-prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl #-}
 prescanl = IV.prescanl
 
 -- | Prefix scan with strict accumulator
-prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+prescanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE prescanl' #-}
 prescanl' = IV.prescanl'
 
 -- | Suffix scan
-postscanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl #-}
 postscanl = IV.postscanl
 
 -- | Suffix scan with strict accumulator
-postscanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+postscanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE postscanl' #-}
 postscanl' = IV.postscanl'
 
 -- | Haskell-style scan
-scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanl :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl #-}
 scanl = IV.scanl
 
 -- | Haskell-style scan with strict accumulator
-scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector b -> Vector a
+scanl' :: (Prim a, Prim b) => (a -> b -> a) -> a -> Vector b -> Vector a
 {-# INLINE scanl' #-}
 scanl' = IV.scanl'
 
 -- | Scan over a non-empty 'Vector'
-scanl1 :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
+scanl1 :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1 #-}
 scanl1 = IV.scanl1
 
 -- | Scan over a non-empty 'Vector' with a strict accumulator
-scanl1' :: Unbox a => (a -> a -> a) -> Vector a -> Vector a
+scanl1' :: Prim a => (a -> a -> a) -> Vector a -> Vector a
 {-# INLINE scanl1' #-}
 scanl1' = IV.scanl1'
 
 -- Enumeration
 -- -----------
 
-enumFromTo :: (Unbox a, Enum a) => a -> a -> Vector a
+enumFromTo :: (Prim a, Enum a) => a -> a -> Vector a
 {-# INLINE enumFromTo #-}
 enumFromTo = IV.enumFromTo
 
-enumFromThenTo :: (Unbox a, Enum a) => a -> a -> a -> Vector a
+enumFromThenTo :: (Prim a, Enum a) => a -> a -> a -> Vector a
 {-# INLINE enumFromThenTo #-}
 enumFromThenTo = IV.enumFromThenTo
 
@@ -438,12 +438,12 @@ enumFromThenTo = IV.enumFromThenTo
 -- ------------------------
 
 -- | Convert a vector to a list
-toList :: Unbox a => Vector a -> [a]
+toList :: Prim a => Vector a -> [a]
 {-# INLINE toList #-}
 toList = IV.toList
 
 -- | Convert a list to a vector
-fromList :: Unbox a => [a] -> Vector a
+fromList :: Prim a => [a] -> Vector a
 {-# INLINE fromList #-}
 fromList = IV.fromList
 
similarity index 77%
rename from Data/Vector/Unboxed/Mutable/IO.hs
rename to Data/Vector/Primitive/Mutable/IO.hs
index 18034ee..9412088 100644 (file)
@@ -1,7 +1,7 @@
 {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}
 
 -- |
--- Module      : Data.Vector.Mutable.Unboxed.IO
+-- Module      : Data.Vector.Mutable.Primitive.IO
 -- Copyright   : (c) Roman Leshchinskiy 2009
 -- License     : BSD-style
 --
@@ -9,15 +9,15 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Mutable unboxed vectors in the IO monad.
+-- Mutable primitive vectors in the IO monad.
 --
 
-module Data.Vector.Unboxed.Mutable.IO ( Vector(..) )
+module Data.Vector.Primitive.Mutable.IO ( Vector(..) )
 where
 
 import           Data.Vector.MVector ( MVector(..), MVectorPure(..) )
-import qualified Data.Vector.Unboxed.Mutable.ST as STV
-import           Data.Vector.Unboxed.Unbox ( Unbox )
+import qualified Data.Vector.Primitive.Mutable.ST as STV
+import           Data.Vector.Primitive.Prim ( Prim )
 
 import GHC.Base   ( RealWorld )
 import GHC.ST     ( ST(..) )
@@ -28,7 +28,7 @@ import Prelude hiding ( length )
 -- | IO-based mutable vectors
 newtype Vector a = Vector (STV.Vector RealWorld a)
 
-instance Unbox a => MVectorPure Vector a where
+instance Prim a => MVectorPure Vector a where
   {-# INLINE length #-}
   length (Vector v) = length v
 
@@ -38,7 +38,7 @@ instance Unbox a => MVectorPure Vector a where
   {-# INLINE overlaps #-}
   overlaps (Vector v1) (Vector v2) = overlaps v1 v2
 
-instance Unbox a => MVector Vector IO a where
+instance Prim a => MVector Vector IO a where
   {-# INLINE unsafeNew #-}
   unsafeNew n = Vector `fmap` stToIO (unsafeNew n)
 
similarity index 83%
rename from Data/Vector/Unboxed/Mutable/ST.hs
rename to Data/Vector/Primitive/Mutable/ST.hs
index dbb9288..ab77081 100644 (file)
@@ -1,7 +1,7 @@
 {-# LANGUAGE MagicHash, UnboxedTuples, MultiParamTypeClasses, FlexibleInstances, ScopedTypeVariables #-}
 
 -- |
--- Module      : Data.Vector.Unboxed.Mutable.ST
+-- Module      : Data.Vector.Primitive.Mutable.ST
 -- Copyright   : (c) Roman Leshchinskiy 2008
 -- License     : BSD-style
 --
@@ -9,15 +9,15 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Mutable unboxed vectors based on 'Unbox' in the ST monad.
+-- Mutable primitive vectors based in the ST monad.
 --
 
-module Data.Vector.Unboxed.Mutable.ST ( Vector(..) )
+module Data.Vector.Primitive.Mutable.ST ( Vector(..) )
 where
 
 import qualified Data.Vector.MVector as MVector
 import           Data.Vector.MVector ( MVector, MVectorPure )
-import           Data.Vector.Unboxed.Unbox
+import           Data.Vector.Primitive.Prim
 
 import GHC.Prim ( MutableByteArray#,
                   newByteArray#, sameMutableByteArray#, (+#) )
@@ -31,7 +31,7 @@ data Vector s a = Vector {-# UNPACK #-} !Int
                          {-# UNPACK #-} !Int
                                         (MutableByteArray# s)
 
-instance Unbox a => MVectorPure (Vector s) a where
+instance Prim a => MVectorPure (Vector s) a where
   length (Vector _ n _) = n
   unsafeSlice (Vector i _ arr#) j m = Vector (i+j) m arr#
 
@@ -43,7 +43,7 @@ instance Unbox a => MVectorPure (Vector s) a where
       between x y z = x >= y && x < z
 
 
-instance Unbox a => MVector (Vector s) (ST s) a where
+instance Prim a => MVector (Vector s) (ST s) a where
   {-# INLINE unsafeNew #-}
   unsafeNew (I# n#) = ST (\s# ->
       case newByteArray# (size# (undefined :: a) n#) s# of
similarity index 87%
rename from Data/Vector/Unboxed/Unbox.hs
rename to Data/Vector/Primitive/Prim.hs
index c5bce9a..bc60307 100644 (file)
@@ -1,7 +1,7 @@
 {-# LANGUAGE MagicHash, UnboxedTuples #-}
 
 -- |
--- Module      : Data.Vector.Unboxed.Unbox
+-- Module      : Data.Vector.Primitive.Prim
 -- Copyright   : (c) Roman Leshchinskiy 2008
 -- License     : BSD-style
 --
@@ -9,11 +9,11 @@
 -- Stability   : experimental
 -- Portability : non-portable
 -- 
--- Primitives for manipulating unboxed arrays
+-- Primitives for manipulating unboxed arrays of primitive types.
 --
 
-module Data.Vector.Unboxed.Unbox (
-  Unbox(..)
+module Data.Vector.Primitive.Prim (
+  Prim(..)
 ) where
 
 import GHC.Base (
@@ -38,8 +38,8 @@ import Data.Array.Base (
     wORD_SCALE, fLOAT_SCALE, dOUBLE_SCALE
   )
 
--- | Class of types which can be stored in unboxed arrays
-class Unbox a where
+-- | Class of types that can be stored in primitive arrays
+class Prim a where
   -- | Yield the size in bytes of a 'ByteArray#' which can store @n@ elements
   size#  :: a     -- ^ Dummy type parameter, never evaluated
          -> Int#  -- ^ Number of elements
@@ -54,7 +54,7 @@ class Unbox a where
   -- | Store the given element at the given position
   write# :: MutableByteArray# s -> Int# -> a -> State# s -> State# s
 
-instance Unbox Word where
+instance Prim Word where
   size# _                   = wORD_SCALE
   at#    arr# i#            = W# (indexWordArray# arr# i#)
   read#  arr# i# s#         = case readWordArray# arr# i# s# of
@@ -62,21 +62,21 @@ instance Unbox Word where
   write# arr# i# (W# n#) s# = writeWordArray# arr# i# n# s#
 
 
-instance Unbox Int where
+instance Prim Int where
   size#  _                  = wORD_SCALE
   at#    arr# i#            = I# (indexIntArray# arr# i#)
   read#  arr# i# s#         = case readIntArray# arr# i# s# of
                                 (# s1#, n# #) -> (# s1#, I# n# #)
   write# arr# i# (I# n#) s# = writeIntArray# arr# i# n# s#
 
-instance Unbox Float where
+instance Prim Float where
   size#  _                  = fLOAT_SCALE
   at#    arr# i#            = F# (indexFloatArray# arr# i#)
   read#  arr# i# s#         = case readFloatArray# arr# i# s# of
                                 (# s1#, x# #) -> (# s1#, F# x# #)
   write# arr# i# (F# x#) s# = writeFloatArray# arr# i# x# s#
 
-instance Unbox Double where
+instance Prim Double where
   size#  _                  = dOUBLE_SCALE
   at#    arr# i#            = D# (indexDoubleArray# arr# i#)
   read#  arr# i# s#         = case readDoubleArray# arr# i# s# of
index 45304dc..50c01c8 100644 (file)
@@ -44,10 +44,10 @@ Library
         Data.Vector.MVector.New
         Data.Vector.IVector
 
-        Data.Vector.Unboxed.Unbox
-        Data.Vector.Unboxed.Mutable.ST
-        Data.Vector.Unboxed.Mutable.IO
-        Data.Vector.Unboxed
+        Data.Vector.Primitive.Prim
+        Data.Vector.Primitive.Mutable.ST
+        Data.Vector.Primitive.Mutable.IO
+        Data.Vector.Primitive
 
         Data.Vector.Storable.Internal
         Data.Vector.Storable.Mutable