Export swap and unsafeSwap
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 15 Feb 2010 03:13:47 +0000 (03:13 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 15 Feb 2010 03:13:47 +0000 (03:13 +0000)
Data/Vector/Generic/Mutable.hs
Data/Vector/Mutable.hs
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable/Mutable.hs
Data/Vector/Unboxed/Mutable.hs

index fcd9b95..5254966 100644 (file)
@@ -16,13 +16,13 @@ module Data.Vector.Generic.Mutable (
   MVector(..),
 
   -- * Operations on mutable vectors
-  length, overlaps, new, newWith, read, write, clear, set, copy, grow,
+  length, overlaps, new, newWith, read, write, swap, clear, set, copy, grow,
 
   slice, take, drop, init, tail,
   unsafeSlice, unsafeInit, unsafeTail,
 
   -- * Unsafe operations
-  unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow,
 
   -- * Internal operations
@@ -444,7 +444,7 @@ write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
 write v i x = BOUNDS_CHECK(checkIndex) "write" i (length v)
             $ unsafeWrite v i x
 
--- | Swap the elements at the gived positions.
+-- | Swap the elements at the given positions.
 swap :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> Int -> m ()
 {-# INLINE swap #-}
 swap v i j = BOUNDS_CHECK(checkIndex) "swap" i (length v)
index 95ff2c4..3cf27de 100644 (file)
@@ -17,7 +17,8 @@ module Data.Vector.Mutable (
   MVector(..), IOVector, STVector,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+  length, overlaps, slice, new, newWith, read, write, swap,
+  clear, set, copy, grow,
 
   -- * Unsafe operations
   unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
@@ -110,6 +111,11 @@ unsafeWrite :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
 {-# INLINE unsafeWrite #-}
 unsafeWrite = G.unsafeWrite
 
+-- | Swap the elements at the given positions. No bounds checks are performed.
+unsafeSwap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE unsafeSwap #-}
+unsafeSwap = G.unsafeSwap
+
 -- | Copy a vector. The two vectors must have the same length and may not
 -- overlap. This is not checked.
 unsafeCopy :: PrimMonad m => MVector (PrimState m) a   -- ^ target
@@ -161,6 +167,11 @@ write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
 {-# INLINE write #-}
 write = G.write
 
+-- | Swap the elements at the given positions.
+swap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE swap #-}
+swap = G.swap
+
 -- | Reset all elements of the vector to some undefined value, clearing all
 -- references to external objects. This is usually a noop for unboxed vectors. 
 clear :: PrimMonad m => MVector (PrimState m) a -> m ()
index c23b63f..c87477f 100644 (file)
@@ -18,10 +18,11 @@ module Data.Vector.Primitive.Mutable (
   MVector(..), IOVector, STVector, Prim,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+  length, overlaps, slice, new, newWith, read, write, swap,
+  clear, set, copy, grow,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow
 ) where
 
@@ -99,6 +100,11 @@ unsafeWrite :: (PrimMonad m, Prim a)
 {-# INLINE unsafeWrite #-}
 unsafeWrite = G.unsafeWrite
 
+-- | Swap the elements at the given positions. No bounds checks are performed.
+unsafeSwap :: (PrimMonad m, Prim a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE unsafeSwap #-}
+unsafeSwap = G.unsafeSwap
 
 -- | Copy a vector. The two vectors must have the same length and may not
 -- overlap. This is not checked.
@@ -151,6 +157,12 @@ write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
 {-# INLINE write #-}
 write = G.write
 
+-- | Swap the elements at the given positions.
+swap :: (PrimMonad m, Prim a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE swap #-}
+swap = G.swap
+
 -- | Reset all elements of the vector to some undefined value, clearing all
 -- references to external objects. This is usually a noop for unboxed vectors. 
 clear :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> m ()
index 4ad26d0..bcd91cb 100644 (file)
@@ -17,10 +17,11 @@ module Data.Vector.Storable.Mutable(
   MVector(..), IOVector, STVector, Storable,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+  length, overlaps, slice, new, newWith, read, write, swap,
+  clear, set, copy, grow,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow
 ) where
 
@@ -103,6 +104,11 @@ unsafeWrite :: (PrimMonad m, Storable a)
 {-# INLINE unsafeWrite #-}
 unsafeWrite = G.unsafeWrite
 
+-- | Swap the elements at the given positions. No bounds checks are performed.
+unsafeSwap :: (PrimMonad m, Storable a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE unsafeSwap #-}
+unsafeSwap = G.unsafeSwap
 
 -- | Copy a vector. The two vectors must have the same length and may not
 -- overlap. This is not checked.
@@ -157,6 +163,12 @@ write :: (PrimMonad m, Storable a)
 {-# INLINE write #-}
 write = G.write
 
+-- | Swap the elements at the given positions.
+swap :: (PrimMonad m, Storable a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE swap #-}
+swap = G.swap
+
 -- | Reset all elements of the vector to some undefined value, clearing all
 -- references to external objects. This is usually a noop for unboxed vectors. 
 clear :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m ()
index 17ca0bc..75ab571 100644 (file)
@@ -15,12 +15,13 @@ module Data.Vector.Unboxed.Mutable (
   MVector(..), IOVector, STVector, Unbox,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+  length, overlaps, slice, new, newWith, read, write, swap,
+  clear, set, copy, grow,
   zip, zip3, zip4, zip5, zip6,
   unzip, unzip3, unzip4, unzip5, unzip6,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow
 ) where
 
@@ -64,6 +65,11 @@ unsafeWrite :: (PrimMonad m, Unbox a)
 {-# INLINE unsafeWrite #-}
 unsafeWrite = G.unsafeWrite
 
+-- | Swap the elements at the given positions. No bounds checks are performed.
+unsafeSwap :: (PrimMonad m, Unbox a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE unsafeSwap #-}
+unsafeSwap = G.unsafeSwap
 
 -- | Copy a vector. The two vectors must have the same length and may not
 -- overlap. This is not checked.
@@ -116,6 +122,12 @@ write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
 {-# INLINE write #-}
 write = G.write
 
+-- | Swap the elements at the given positions.
+swap :: (PrimMonad m, Unbox a)
+                => MVector (PrimState m) a -> Int -> Int -> m ()
+{-# INLINE swap #-}
+swap = G.swap
+
 -- | Reset all elements of the vector to some undefined value, clearing all
 -- references to external objects. This is usually a noop for unboxed vectors. 
 clear :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m ()