Split Unboxed.Unbox and rename stuff
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 5 Jul 2008 01:53:37 +0000 (01:53 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sat, 5 Jul 2008 01:53:37 +0000 (01:53 +0000)
Data/Vector/Unboxed.hs
Data/Vector/Unboxed/Mutable.hs
Data/Vector/Unboxed/Prim.hs [new file with mode: 0644]
Data/Vector/Unboxed/Unbox.hs
vector.cabal

index 6686eaf..0d033b2 100644 (file)
@@ -3,8 +3,9 @@
 module Data.Vector.Unboxed
 where
 
 module Data.Vector.Unboxed
 where
 
-import Data.Vector.Unboxed.Unbox
+import qualified Data.Vector.Unboxed.Prim as Prim
 import qualified Data.Vector.Unboxed.Mutable as Mut
 import qualified Data.Vector.Unboxed.Mutable as Mut
+import           Data.Vector.Unboxed.Unbox ( Unbox )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Step(..), Stream(..) )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Step(..), Stream(..) )
@@ -14,9 +15,9 @@ import Control.Monad.ST  ( ST, runST )
 
 import Prelude hiding ( length )
 
 
 import Prelude hiding ( length )
 
-data Vector a = Vector !Int
-                       !Int
-                       !(Array a)
+data Vector a = Vector {-# UNPACK #-} !Int
+                       {-# UNPACK #-} !Int
+                       {-# UNPACK #-} !(Prim.Vector a)
 
 new :: Unbox a
     => Int -> (forall s. Mut.Vector s a -> ST s (Mut.Vector s a)) -> Vector a
 
 new :: Unbox a
     => Int -> (forall s. Mut.Vector s a -> ST s (Mut.Vector s a)) -> Vector a
@@ -25,9 +26,9 @@ new n init = runST (
   do
     mv  <- Mut.new n
     mv' <- init mv
   do
     mv  <- Mut.new n
     mv' <- init mv
-    let (marr, i, n') = Mut.dataOf mv'
-    arr <- unsafeFreezeArray marr
-    return $ Vector i n' arr
+    let (mprim, i, n') = Mut.dataOf mv'
+    prim <- Prim.unsafeFreeze mprim
+    return $ Vector i n' prim
   )
 
 stream :: Unbox a => Vector a -> Stream a
   )
 
 stream :: Unbox a => Vector a -> Stream a
@@ -37,7 +38,7 @@ stream (Vector i n arr) = Stream get i n
     n' = n+i
 
     {-# INLINE get #-}
     n' = n+i
 
     {-# INLINE get #-}
-    get j | j < n'    = Yield (indexArray arr j) (j+1)
+    get j | j < n'    = Yield (Prim.at arr j) (j+1)
           | otherwise = Done
 
 unstream :: Unbox a => Stream a -> Vector a
           | otherwise = Done
 
 unstream :: Unbox a => Stream a -> Vector a
@@ -67,7 +68,7 @@ slice (Vector i n arr) j m
 
 unsafeAt :: Unbox a => Vector a -> Int -> a
 {-# INLINE unsafeAt #-}
 
 unsafeAt :: Unbox a => Vector a -> Int -> a
 {-# INLINE unsafeAt #-}
-unsafeAt (Vector i _ arr) j = indexArray arr (i+j)
+unsafeAt (Vector i _ arr) j = Prim.at arr (i+j)
 
 at :: Unbox a => Vector a -> Int -> a
 {-# INLINE at #-}
 
 at :: Unbox a => Vector a -> Int -> a
 {-# INLINE at #-}
index bca78fa..97b10a4 100644 (file)
@@ -7,7 +7,8 @@ module Data.Vector.Unboxed.Mutable (
   dataOf
 ) where
 
   dataOf
 ) where
 
-import Data.Vector.Unboxed.Unbox
+import qualified Data.Vector.Unboxed.Prim as Prim
+import           Data.Vector.Unboxed.Unbox ( Unbox )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Stream )
 
 import qualified Data.Vector.Stream as Stream
 import           Data.Vector.Stream ( Stream )
@@ -17,20 +18,18 @@ import Control.Monad.ST  ( ST )
 
 import Prelude hiding ( length, read )
 
 
 import Prelude hiding ( length, read )
 
-data Vector s a = Vector !Int                  -- ^ start
-                         !Int                  -- ^ length
-                         !(MutableArray s a)   -- ^ data
+data Vector s a = Vector {-# UNPACK #-} !Int                       -- ^ start
+                         {-# UNPACK #-} !Int                       -- ^ length
+                         {-# UNPACK #-} !(Prim.MutableVector s a)  -- ^ data
 
 
-dataOf :: Vector s a -> (MutableArray s a, Int, Int)
+dataOf :: Vector s a -> (Prim.MutableVector s a, Int, Int)
 {-# INLINE dataOf #-}
 {-# INLINE dataOf #-}
-dataOf (Vector i n arr) = (arr, i, n)
+dataOf (Vector i n v) = (v, i, n)
 
 new :: Unbox a => Int -> ST s (Vector s a)
 {-# INLINE new #-}
 new n = assert (n >= 0)
 
 new :: Unbox a => Int -> ST s (Vector s a)
 {-# INLINE new #-}
 new n = assert (n >= 0)
-      $ do
-          arr <- newArray n
-          return $ Vector 0 n arr
+      $ Vector 0 n `fmap` Prim.new n
 
 length :: Unbox a => Vector s a -> Int
 {-# INLINE length #-}
 
 length :: Unbox a => Vector s a -> Int
 {-# INLINE length #-}
@@ -38,27 +37,27 @@ length (Vector _ n _) = n
 
 slice :: Unbox a => Vector s a -> Int -> Int -> Vector s a
 {-# INLINE slice #-}
 
 slice :: Unbox a => Vector s a -> Int -> Int -> Vector s a
 {-# INLINE slice #-}
-slice (Vector i n arr) j m
+slice (Vector i n v) j m
   = assert (j + m <= n && j >= 0 && m >= 0)
   = assert (j + m <= n && j >= 0 && m >= 0)
-  $ Vector (i+j) m arr
+  $ Vector (i+j) m v
 
 slicel :: Unbox a => Vector s a -> Int -> Vector s a
 {-# INLINE slicel #-}
 
 slicel :: Unbox a => Vector s a -> Int -> Vector s a
 {-# INLINE slicel #-}
-slicel (Vector i n arr) m
+slicel (Vector i n v) m
   = assert (m <= n && m >= 0)
   = assert (m <= n && m >= 0)
-  $ Vector i m arr
+  $ Vector i m v
 
 read :: Unbox a => Vector s a -> Int -> ST s a
 {-# INLINE read #-}
 
 read :: Unbox a => Vector s a -> Int -> ST s a
 {-# INLINE read #-}
-read (Vector i n arr) j
+read (Vector i n v) j
   = assert (j < n)
   = assert (j < n)
-  $ readArray arr (i+j)
+  $ Prim.read v (i+j)
 
 write :: Unbox a => Vector s a -> Int -> a -> ST s ()
 {-# INLINE write #-}
 
 write :: Unbox a => Vector s a -> Int -> a -> ST s ()
 {-# INLINE write #-}
-write (Vector i n arr) j x
+write (Vector i n v) j x
   = assert (j < n)
   = assert (j < n)
-  $ writeArray arr (i+j) x
+  $ Prim.write v (i+j) x
 
 fill :: Unbox a => Vector s a -> Stream a -> ST s Int
 {-# INLINE fill #-}
 
 fill :: Unbox a => Vector s a -> Stream a -> ST s Int
 {-# INLINE fill #-}
diff --git a/Data/Vector/Unboxed/Prim.hs b/Data/Vector/Unboxed/Prim.hs
new file mode 100644 (file)
index 0000000..4bc224c
--- /dev/null
@@ -0,0 +1,55 @@
+{-# LANGUAGE MagicHash, UnboxedTuples, ScopedTypeVariables #-}
+
+module Data.Vector.Unboxed.Prim (
+  Unbox(..), Vector, MutableVector,
+
+  size, new, unsafeFreeze, at, read, write
+) where
+
+import Data.Vector.Unboxed.Unbox
+
+import GHC.Prim (
+    ByteArray#, MutableByteArray#,
+    newByteArray#, unsafeFreezeByteArray#,
+  )
+import GHC.ST (
+    ST(..)
+  )
+import GHC.Base (
+    Int(..)
+  )
+
+import Prelude hiding ( read )
+
+data Vector          a = Vector        ByteArray#
+data MutableVector s a = MutableVector (MutableByteArray# s)
+
+size :: Unbox a => a -> Int -> Int
+{-# INLINE size #-}
+size a (I# i#) = I# (size# a i#)
+
+new :: forall s a. Unbox a => Int -> ST s (MutableVector s a)
+{-# INLINE new #-}
+new (I# n#) = ST $ \s# ->
+  case newByteArray# (size# (undefined :: a) n#) s# of
+    (# s2#, arr# #) -> (# s2#, MutableVector arr# #)
+
+unsafeFreeze :: Unbox a => MutableVector s a -> ST s (Vector a)
+{-# INLINE unsafeFreeze #-}
+unsafeFreeze (MutableVector arr#) = ST $ \s# ->
+  case unsafeFreezeByteArray# arr# s# of
+    (# s2, frozen# #) -> (# s2, Vector frozen# #)
+
+at :: Unbox a => Vector a -> Int -> a
+{-# INLINE at #-}
+at (Vector arr#) (I# i#) = at# arr# i#
+
+read :: Unbox a => MutableVector s a -> Int -> ST s a
+{-# INLINE read #-}
+read (MutableVector arr#) (I# i#) = ST $ read# arr# i#
+
+write :: Unbox a => MutableVector s a -> Int -> a -> ST s ()
+{-# INLINE write #-}
+write (MutableVector arr#) (I# i#) x = ST $ \s# ->
+  case write# arr# i# x s# of s2# -> (# s2#, () #)
+
index a4c277b..79a25cd 100644 (file)
@@ -1,68 +1,32 @@
-{-# LANGUAGE MagicHash, UnboxedTuples, ScopedTypeVariables #-}
+{-# LANGUAGE MagicHash, UnboxedTuples #-}
 
 module Data.Vector.Unboxed.Unbox (
 
 module Data.Vector.Unboxed.Unbox (
-  Unbox(..), Array, MutableArray,
-
-  arraySize, newArray, unsafeFreezeArray, indexArray, readArray, writeArray
+  Unbox(..)
 ) where
 
 ) where
 
+import GHC.Base (
+    Int(..)
+  )
+
 import GHC.Prim (
     ByteArray#, MutableByteArray#, State#,
 import GHC.Prim (
     ByteArray#, MutableByteArray#, State#,
-    newByteArray#, unsafeFreezeByteArray#,
 
     Int#, indexIntArray#, readIntArray#, writeIntArray#
   )
 
     Int#, indexIntArray#, readIntArray#, writeIntArray#
   )
-import GHC.ST (
-    ST(..)
-  )
-import GHC.Base (
-    Int(..)
-  )
 import Data.Array.Base (
 import Data.Array.Base (
-    wORD_SCALE )
-
-data Array          a = Array        ByteArray#
-data MutableArray s a = MutableArray (MutableByteArray# s)
+    wORD_SCALE
+  )
 
 class Unbox a where
 
 class Unbox a where
-  arraySize#  :: a -> Int# -> Int#
-  indexArray# :: ByteArray# -> Int# -> a
-  readArray#  :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
-  writeArray# :: MutableByteArray# s -> Int# -> a -> State# s -> State# s
+  size#  :: a -> Int# -> Int#
+  at#    :: ByteArray# -> Int# -> a
+  read#  :: MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
+  write# :: MutableByteArray# s -> Int# -> a -> State# s -> State# s
 
 instance Unbox Int where
 
 instance Unbox Int where
-  arraySize#  _                  = wORD_SCALE
-  indexArray# arr# i#            = I# (indexIntArray# arr# i#)
-  readArray#  arr# i# s#         = case readIntArray# arr# i# s# of
-                                     (# s1#, n# #) -> (# s1#, I# n# #)
-  writeArray# arr# i# (I# n#) s# = writeIntArray# arr# i# n# s#
-
-arraySize :: Unbox a => a -> Int -> Int
-{-# INLINE arraySize #-}
-arraySize a (I# i#) = I# (arraySize# a i#)
-
-newArray :: forall s a. Unbox a => Int -> ST s (MutableArray s a)
-{-# INLINE newArray #-}
-newArray (I# n#) = ST $ \s# ->
-  case newByteArray# (arraySize# (undefined :: a) n#) s# of
-    (# s2#, arr# #) -> (# s2#, MutableArray arr# #)
-
-unsafeFreezeArray :: Unbox a => MutableArray s a -> ST s (Array a)
-{-# INLINE unsafeFreezeArray #-}
-unsafeFreezeArray (MutableArray arr#) = ST $ \s# ->
-  case unsafeFreezeByteArray# arr# s# of
-    (# s2, frozen# #) -> (# s2, Array frozen# #)
-
-indexArray :: Unbox a => Array a -> Int -> a
-{-# INLINE indexArray #-}
-indexArray (Array arr#) (I# i#) = indexArray# arr# i#
-
-readArray :: Unbox a => MutableArray s a -> Int -> ST s a
-{-# INLINE readArray #-}
-readArray (MutableArray arr#) (I# i#) = ST $ readArray# arr# i#
-
-writeArray :: Unbox a => MutableArray s a -> Int -> a -> ST s ()
-{-# INLINE writeArray #-}
-writeArray (MutableArray arr#) (I# i#) x = ST $ \s# ->
-  case writeArray# arr# i# x s# of s2# -> (# s2#, () #)
+  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#
 
 
index 2c243f5..c43f47f 100644 (file)
@@ -13,6 +13,7 @@ Build-Type:     Simple
 Library
   Exposed-Modules:
         Data.Vector.Unboxed.Unbox
 Library
   Exposed-Modules:
         Data.Vector.Unboxed.Unbox
+        Data.Vector.Unboxed.Prim
         Data.Vector.Unboxed.Mutable
         Data.Vector.Unboxed
         Data.Vector.Stream
         Data.Vector.Unboxed.Mutable
         Data.Vector.Unboxed
         Data.Vector.Stream