Finish Stream -> Bundle renaming
[darcs-mirrors/vector.git] / Data / Vector / Primitive.hs
index 56ae9c4..644cc09 100644 (file)
@@ -136,10 +136,12 @@ module Data.Vector.Primitive (
 
 import qualified Data.Vector.Generic           as G
 import           Data.Vector.Primitive.Mutable ( MVector(..) )
-import qualified Data.Vector.Fusion.Stream as Stream
+import qualified Data.Vector.Fusion.Bundle as Bundle
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 
+import Control.DeepSeq ( NFData )
+
 import Control.Monad ( liftM )
 import Control.Monad.ST ( ST )
 import Control.Monad.Primitive
@@ -162,6 +164,7 @@ import qualified Prelude
 
 import Data.Typeable ( Typeable )
 import Data.Data     ( Data(..) )
+import Text.Read     ( Read(..), readListPrecDefault )
 
 import Data.Monoid   ( Monoid(..) )
 
@@ -171,8 +174,14 @@ data Vector a = Vector {-# UNPACK #-} !Int
                        {-# UNPACK #-} !ByteArray
   deriving ( Typeable )
 
+instance NFData (Vector a)
+
 instance (Show a, Prim a) => Show (Vector a) where
-    show = (Prelude.++ " :: Data.Vector.Primitive.Vector") . ("fromList " Prelude.++) . show . toList
+  showsPrec = G.showsPrec
+
+instance (Read a, Prim a) => Read (Vector a) where
+  readPrec = G.readPrec
+  readListPrec = readListPrecDefault
 
 instance (Data a, Prim a) => Data (Vector a) where
   gfoldl       = G.gfoldl
@@ -200,11 +209,11 @@ instance Prim a => G.Vector Vector a where
   basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
 
   {-# INLINE basicUnsafeIndexM #-}
-  basicUnsafeIndexM (Vector i _ arr) j = return (indexByteArray arr (i+j))
+  basicUnsafeIndexM (Vector i _ arr) j = return $! indexByteArray arr (i+j)
 
   {-# INLINE basicUnsafeCopy #-}
   basicUnsafeCopy (MVector i n dst) (Vector j _ src)
-    = copyByteArray src (j*sz) dst (i*sz) (n*sz)
+    = copyByteArray dst (i*sz) src (j*sz) (n*sz)
     where
       sz = sizeOf (undefined :: a)
 
@@ -214,27 +223,27 @@ instance Prim a => G.Vector Vector a where
 -- See http://trac.haskell.org/vector/ticket/12
 instance (Prim a, Eq a) => Eq (Vector a) where
   {-# INLINE (==) #-}
-  xs == ys = Stream.eq (G.stream xs) (G.stream ys)
+  xs == ys = Bundle.eq (G.stream xs) (G.stream ys)
 
   {-# INLINE (/=) #-}
-  xs /= ys = not (Stream.eq (G.stream xs) (G.stream ys))
+  xs /= ys = not (Bundle.eq (G.stream xs) (G.stream ys))
 
 -- See http://trac.haskell.org/vector/ticket/12
 instance (Prim a, Ord a) => Ord (Vector a) where
   {-# INLINE compare #-}
-  compare xs ys = Stream.cmp (G.stream xs) (G.stream ys)
+  compare xs ys = Bundle.cmp (G.stream xs) (G.stream ys)
 
   {-# INLINE (<) #-}
-  xs < ys = Stream.cmp (G.stream xs) (G.stream ys) == LT
+  xs < ys = Bundle.cmp (G.stream xs) (G.stream ys) == LT
 
   {-# INLINE (<=) #-}
-  xs <= ys = Stream.cmp (G.stream xs) (G.stream ys) /= GT
+  xs <= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= GT
 
   {-# INLINE (>) #-}
-  xs > ys = Stream.cmp (G.stream xs) (G.stream ys) == GT
+  xs > ys = Bundle.cmp (G.stream xs) (G.stream ys) == GT
 
   {-# INLINE (>=) #-}
-  xs >= ys = Stream.cmp (G.stream xs) (G.stream ys) /= LT
+  xs >= ys = Bundle.cmp (G.stream xs) (G.stream ys) /= LT
 
 instance Prim a => Monoid (Vector a) where
   {-# INLINE mempty #-}
@@ -578,7 +587,7 @@ generateM = G.generateM
 -- | Execute the monadic action and freeze the resulting vector.
 --
 -- @
--- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\' }) = \<'a','b'\>
+-- create (do { v \<- new 2; write v 0 \'a\'; write v 1 \'b\'; return v }) = \<'a','b'\>
 -- @
 create :: Prim a => (forall s. ST s (MVector s a)) -> Vector a
 {-# INLINE create #-}