Export create, modify and copy/unsafeCopy
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 18 Apr 2010 04:14:49 +0000 (04:14 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 18 Apr 2010 04:14:49 +0000 (04:14 +0000)
Data/Vector.hs
Data/Vector/Generic.hs
Data/Vector/Primitive.hs
Data/Vector/Storable.hs
Data/Vector/Unboxed.hs

index e8c345d..f25cad6 100644 (file)
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies #-}
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies, Rank2Types #-}
 
 -- |
 -- Module      : Data.Vector
@@ -114,7 +114,10 @@ module Data.Vector (
   enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
 
   -- * Conversion to/from lists
-  toList, fromList, fromListN
+  toList, fromList, fromListN,
+
+  -- * Destructive operations
+  create, modify, copy, unsafeCopy
 ) where
 
 import qualified Data.Vector.Generic as G
@@ -123,6 +126,8 @@ import           Data.Primitive.Array
 import qualified Data.Vector.Fusion.Stream as Stream
 
 import Control.Monad ( liftM )
+import Control.Monad.ST ( ST )
+import Control.Monad.Primitive
 
 import Prelude hiding ( length, null,
                         replicate, (++),
@@ -999,3 +1004,29 @@ fromListN :: Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
+-- Destructive operations
+-- ----------------------
+
+-- | Destructively initialise a vector.
+create :: (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- | Apply a destructive operation to a vector. The operation is applied to a
+-- copy of the vector unless it can be safely performed in place.
+modify :: (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
+-- | Copy an immutable vector into a mutable one. The two vectors must have
+-- the same length. This is not checked.
+unsafeCopy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+           
+-- | Copy an immutable vector into a mutable one. The two vectors must have the
+-- same length.
+copy :: PrimMonad m => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
+
index a8f0de4..75d277e 100644 (file)
@@ -85,11 +85,14 @@ module Data.Vector.Generic (
   -- * Conversion to/from lists
   toList, fromList, fromListN,
 
+  -- * Destructive operations
+  create, modify, copy, unsafeCopy,
+
   -- * Conversion to/from Streams
   stream, unstream, streamR, unstreamR,
 
-  -- * MVector-based initialisation
-  new, copy, unsafeCopy,
+  -- * Recycling support
+  new, clone,
 
   -- * Utilities for defining Data instances
   gfoldl, dataCast, mkType
@@ -228,6 +231,21 @@ unstreamR s = new (New.unstreamR s)
 
  #-}
 
+
+-- Destructive operations
+-- ----------------------
+
+-- | Destructively initialise a vector.
+create :: Vector v a => (forall s. ST s (Mutable v s a)) -> v a
+{-# INLINE create #-}
+create p = new (New.create p)
+
+-- | Apply a destructive operation to a vector. The operation is applied to a
+-- copy of the vector unless it can be safely performed in place.
+modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
+{-# INLINE modify #-}
+modify p = new . New.modify p . clone
+
 -- | Copy an immutable vector into a mutable one. The two vectors must have
 -- the same length. This is not checked.
 unsafeCopy
@@ -237,7 +255,7 @@ unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
                                          (M.length dst == length src)
                    $ (dst `seq` src `seq` basicUnsafeCopy dst src)
            
--- | Copy an immutable vector into a mutale one. The two vectors must have the
+-- | Copy an immutable vector into a mutable one. The two vectors must have the
 -- same length.
 copy
   :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
@@ -246,10 +264,6 @@ copy dst src = BOUNDS_CHECK(check) "copy" "length mismatch"
                                           (M.length dst == length src)
              $ unsafeCopy dst src
 
-modify :: Vector v a => (forall s. Mutable v s a -> ST s ()) -> v a -> v a
-{-# INLINE modify #-}
-modify p = new . New.modify p . clone
-
 -- Length
 -- ------
 
index 8b4c6cd..741e575 100644 (file)
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies, ScopedTypeVariables #-}
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, TypeFamilies, ScopedTypeVariables, Rank2Types #-}
 
 -- |
 -- Module      : Data.Vector.Primitive
@@ -75,7 +75,10 @@ module Data.Vector.Primitive (
   enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
 
   -- * Conversion to/from lists
-  toList, fromList, fromListN
+  toList, fromList, fromListN,
+
+  -- * Destructive operations
+  create, modify, copy, unsafeCopy
 ) where
 
 import qualified Data.Vector.Generic           as G
@@ -85,6 +88,8 @@ import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 
 import Control.Monad ( liftM )
+import Control.Monad.ST ( ST )
+import Control.Monad.Primitive
 
 import Prelude hiding ( length, null,
                         replicate, (++),
@@ -850,3 +855,30 @@ fromListN :: Prim a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
+-- Destructive operations
+-- ----------------------
+
+-- | Destructively initialise a vector.
+create :: Prim a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- | Apply a destructive operation to a vector. The operation is applied to a
+-- copy of the vector unless it can be safely performed in place.
+modify :: Prim a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
+-- | Copy an immutable vector into a mutable one. The two vectors must have
+-- the same length. This is not checked.
+unsafeCopy
+  :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+           
+-- | Copy an immutable vector into a mutable one. The two vectors must have the
+-- same length.
+copy :: (Prim a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
+
index daa7538..0afc25f 100644 (file)
@@ -1,4 +1,4 @@
-{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies, ScopedTypeVariables #-}
+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies, ScopedTypeVariables, Rank2Types #-}
 
 -- |
 -- Module      : Data.Vector.Storable
@@ -77,6 +77,9 @@ module Data.Vector.Storable (
   -- * Conversion to/from lists
   toList, fromList, fromListN,
 
+  -- * Destructive operations
+  create, modify, copy, unsafeCopy,
+
   -- * Accessing the underlying memory
   unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith
 ) where
@@ -92,7 +95,8 @@ import Foreign.Ptr
 import Foreign.Marshal.Array ( advancePtr )
 import Foreign.Marshal.Utils ( copyBytes )
 
-import Control.Monad.Primitive ( unsafePrimToPrim )
+import Control.Monad.ST ( ST )
+import Control.Monad.Primitive
 
 import Prelude hiding ( length, null,
                         replicate, (++),
@@ -906,6 +910,34 @@ fromListN :: Storable a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
+-- Destructive operations
+-- ----------------------
+
+-- | Destructively initialise a vector.
+create :: Storable a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- | Apply a destructive operation to a vector. The operation is applied to a
+-- copy of the vector unless it can be safely performed in place.
+modify
+  :: Storable a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
+-- | Copy an immutable vector into a mutable one. The two vectors must have
+-- the same length. This is not checked.
+unsafeCopy
+  :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+           
+-- | Copy an immutable vector into a mutable one. The two vectors must have the
+-- same length.
+copy :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
+
 -- Accessing the underlying memory
 -- -------------------------------
 
@@ -931,3 +963,4 @@ unsafeWith :: Storable a => Vector a -> (Ptr a -> IO b) -> IO b
 {-# INLINE unsafeWith #-}
 unsafeWith (Vector p n fp) m = withForeignPtr fp $ \_ -> m p
 
+
index 2aaad85..ed13a87 100644 (file)
@@ -1,3 +1,5 @@
+{-# LANGUAGE Rank2Types #-}
+
 -- |
 -- Module      : Data.Vector.Unboxed
 -- Copyright   : (c) Roman Leshchinskiy 2009-2010
@@ -77,13 +79,19 @@ module Data.Vector.Unboxed (
   enumFromN, enumFromStepN, enumFromTo, enumFromThenTo,
 
   -- * Conversion to/from lists
-  toList, fromList, fromListN
+  toList, fromList, fromListN,
+
+  -- * Destructive operations
+  create, modify, copy, unsafeCopy
 ) where
 
 import Data.Vector.Unboxed.Base
 import qualified Data.Vector.Generic as G
 import qualified Data.Vector.Fusion.Stream as Stream
 
+import Control.Monad.ST ( ST )
+import Control.Monad.Primitive
+
 import Prelude hiding ( length, null,
                         replicate, (++),
                         head, last,
@@ -833,6 +841,34 @@ fromListN :: Unbox a => Int -> [a] -> Vector a
 {-# INLINE fromListN #-}
 fromListN = G.fromListN
 
+-- Destructive operations
+-- ----------------------
+
+-- | Destructively initialise a vector.
+create :: Unbox a => (forall s. ST s (MVector s a)) -> Vector a
+{-# INLINE create #-}
+create = G.create
+
+-- | Apply a destructive operation to a vector. The operation is applied to a
+-- copy of the vector unless it can be safely performed in place.
+modify :: Unbox a => (forall s. MVector s a -> ST s ()) -> Vector a -> Vector a
+{-# INLINE modify #-}
+modify = G.modify
+
+-- | Copy an immutable vector into a mutable one. The two vectors must have
+-- the same length. This is not checked.
+unsafeCopy
+  :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+           
+-- | Copy an immutable vector into a mutable one. The two vectors must have the
+-- same length.
+copy :: (Unbox a, PrimMonad m) => MVector (PrimState m) a -> Vector a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
+
+
 #define DEFINE_IMMUTABLE
 #include "unbox-tuple-instances"