Add Mutable.replicate and deprecate Mutable.n{newWith,unsafeNewWith}
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 5 May 2010 14:45:50 +0000 (14:45 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 5 May 2010 14:45:50 +0000 (14:45 +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 3e639bf..278a6c2 100644 (file)
@@ -16,13 +16,13 @@ module Data.Vector.Generic.Mutable (
   MVector(..),
 
   -- * Operations on mutable vectors
-  length, overlaps, new, newWith, read, write, swap, clear, set, copy, grow,
+  length, overlaps, new, replicate, read, write, swap, clear, set, copy, grow,
 
   slice, take, drop, init, tail,
   unsafeSlice, unsafeTake, unsafeDrop, unsafeInit, unsafeTail,
 
   -- * Unsafe operations
-  unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
+  unsafeNew, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow,
 
   -- * Internal operations
@@ -31,17 +31,21 @@ module Data.Vector.Generic.Mutable (
   transform, transformR,
   fill, fillR,
   unsafeAccum, accum, unsafeUpdate, update, reverse,
-  unstablePartition, unstablePartitionStream, partitionStream
+  unstablePartition, unstablePartitionStream, partitionStream,
+
+  -- * Deprecated operations
+  newWith, unsafeNewWith
 ) where
 
 import qualified Data.Vector.Fusion.Stream      as Stream
 import           Data.Vector.Fusion.Stream      ( Stream, MStream )
 import qualified Data.Vector.Fusion.Stream.Monadic as MStream
 import           Data.Vector.Fusion.Stream.Size
+import           Data.Vector.Fusion.Util        ( delay_inline )
 
 import Control.Monad.Primitive ( PrimMonad, PrimState )
 
-import Prelude hiding ( length, reverse, map, read,
+import Prelude hiding ( length, replicate, reverse, map, read,
                         take, drop, init, tail )
 
 #include "vector.h"
@@ -70,8 +74,8 @@ class MVector v a where
 
   -- | Create a mutable vector of the given length and fill it with an
   -- initial value. This method should not be called directly, use
-  -- 'unsafeNewWith' instead.
-  basicUnsafeNewWith :: PrimMonad m => Int -> a -> m (v (PrimState m) a)
+  -- 'replicate' instead.
+  basicUnsafeReplicate :: PrimMonad m => Int -> a -> m (v (PrimState m) a)
 
   -- | Yield the element at the given position. This method should not be
   -- called directly, use 'unsafeRead' instead.
@@ -101,6 +105,12 @@ class MVector v a where
   basicUnsafeGrow  :: PrimMonad m => v (PrimState m) a -> Int
                                                        -> m (v (PrimState m) a)
 
+  -- | /DEPRECATED/ in favour of 'basicUnsafeReplicate'
+  basicUnsafeNewWith :: PrimMonad m => Int -> a -> m (v (PrimState m) a)
+
+  {-# INLINE basicUnsafeReplicate #-}
+  basicUnsafeReplicate = basicUnsafeNewWith
+
   {-# INLINE basicUnsafeNewWith #-}
   basicUnsafeNewWith n x
     = do
@@ -141,6 +151,8 @@ class MVector v a where
     where
       n = basicLength v
 
+{-# DEPRECATED basicUnsafeNewWith "define and use basicUnsafeReplicate instead" #-}
+
 -- ------------------
 -- Internal functions
 -- ------------------
@@ -490,26 +502,29 @@ new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
 new n = BOUNDS_CHECK(checkLength) "new" n
       $ unsafeNew n
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value.
-newWith :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
-{-# INLINE newWith #-}
-newWith n x = BOUNDS_CHECK(checkLength) "newWith" n
-            $ unsafeNewWith n x
-
 -- | Create a mutable vector of the given length. The length is not checked.
 unsafeNew :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
 {-# INLINE unsafeNew #-}
 unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
             $ basicUnsafeNew n
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value. The length is not checked.
+-- | Create a mutable vector of the given length (0 if the length is negative)
+-- and fill it with an initial value.
+replicate :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
+{-# INLINE replicate #-}
+replicate n x = basicUnsafeReplicate (delay_inline max 0 n) x
+
+-- | /DEPRECATED/ Use 'replicate' instead
+newWith :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
+{-# INLINE newWith #-}
+newWith = replicate
+
+-- | /DEPRECATED/ Use 'replicate' instead
 unsafeNewWith :: (PrimMonad m, MVector v a) => Int -> a -> m (v (PrimState m) a)
 {-# INLINE unsafeNewWith #-}
-unsafeNewWith n x = UNSAFE_CHECK(checkLength) "unsafeNewWith" n
-                  $ basicUnsafeNewWith n x
+unsafeNewWith = replicate
 
+{-# DEPRECATED newWith, unsafeNewWith "Use replicate instead" #-}
 
 -- Growing
 -- -------
index 5f2219c..6498a5e 100644 (file)
@@ -17,19 +17,22 @@ module Data.Vector.Mutable (
   MVector(..), IOVector, STVector,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, swap,
+  length, overlaps, slice, new, replicate, read, write, swap,
   clear, set, copy, grow,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
-  unsafeCopy, unsafeGrow
+  unsafeSlice, unsafeNew, unsafeRead, unsafeWrite,
+  unsafeCopy, unsafeGrow,
+
+  -- * Deprecated operations
+  newWith, unsafeNewWith
 ) where
 
 import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.Array
 import           Control.Monad.Primitive
 
-import Prelude hiding ( length, read )
+import Prelude hiding ( length, replicate, read )
 
 import Data.Typeable ( Typeable )
 
@@ -64,8 +67,8 @@ instance G.MVector MVector a where
         arr <- newArray n uninitialised
         return (MVector 0 n arr)
 
-  {-# INLINE basicUnsafeNewWith #-}
-  basicUnsafeNewWith n x
+  {-# INLINE basicUnsafeReplicate #-}
+  basicUnsafeReplicate n x
     = do
         arr <- newArray n x
         return (MVector 0 n arr)
@@ -97,12 +100,6 @@ unsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) a)
 {-# INLINE unsafeNew #-}
 unsafeNew = G.unsafeNew
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value. The length is not checked.
-unsafeNewWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE unsafeNewWith #-}
-unsafeNewWith = G.unsafeNewWith
-
 -- | Yield the element at the given position. No bounds checks are performed.
 unsafeRead :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
 {-# INLINE unsafeRead #-}
@@ -153,11 +150,11 @@ new :: PrimMonad m => Int -> m (MVector (PrimState m) a)
 {-# INLINE new #-}
 new = G.new
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value.
-newWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE newWith #-}
-newWith = G.newWith
+-- | Create a mutable vector of the given length (0 if the length is negative)
+-- and fill it with an initial value.
+replicate :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE replicate #-}
+replicate = G.replicate
 
 -- | Yield the element at the given position.
 read :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
@@ -199,3 +196,16 @@ grow :: PrimMonad m
 {-# INLINE grow #-}
 grow = G.grow
 
+
+-- | /DEPRECATED/ Use 'replicate' instead
+newWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE newWith #-}
+newWith = G.replicate
+
+-- | /DEPRECATED/ Use 'replicate' instead
+unsafeNewWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE unsafeNewWith #-}
+unsafeNewWith = G.replicate
+
+{-# DEPRECATED newWith, unsafeNewWith "Use replicate instead" #-}
+
index b19596e..e804fb3 100644 (file)
@@ -17,12 +17,15 @@ module Data.Vector.Primitive.Mutable (
   MVector(..), IOVector, STVector, Prim,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, swap,
+  length, overlaps, slice, new, replicate, read, write, swap,
   clear, set, copy, grow,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
-  unsafeCopy, unsafeGrow
+  unsafeSlice, unsafeNew, unsafeRead, unsafeWrite, unsafeSwap,
+  unsafeCopy, unsafeGrow,
+
+  -- * Deprecated operations
+  newWith, unsafeNewWith
 ) where
 
 import qualified Data.Vector.Generic.Mutable as G
@@ -31,7 +34,7 @@ import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
 import           Control.Monad ( liftM )
 
-import Prelude hiding( length, read )
+import Prelude hiding( length, replicate, read )
 
 import Data.Typeable ( Typeable )
 
@@ -89,13 +92,6 @@ unsafeNew :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE unsafeNew #-}
 unsafeNew = G.unsafeNew
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value. The length is not checked.
-unsafeNewWith :: (PrimMonad m, Prim a)
-                                => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE unsafeNewWith #-}
-unsafeNewWith = G.unsafeNewWith
-
 -- | Yield the element at the given position. No bounds checks are performed.
 unsafeRead :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
 {-# INLINE unsafeRead #-}
@@ -148,11 +144,11 @@ new :: (PrimMonad m, Prim a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE new #-}
 new = G.new
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value.
-newWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE newWith #-}
-newWith = G.newWith
+-- | Create a mutable vector of the given length (0 if the length is negative)
+-- and fill it with an initial value.
+replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE replicate #-}
+replicate = G.replicate
 
 -- | Yield the element at the given position.
 read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
@@ -195,3 +191,16 @@ grow :: (PrimMonad m, Prim a)
 {-# INLINE grow #-}
 grow = G.grow
 
+
+-- | /DEPRECATED/ Use 'replicate' instead
+newWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE newWith #-}
+newWith = G.replicate
+
+-- | /DEPRECATED/ Use 'replicate' instead
+unsafeNewWith :: (PrimMonad m, Prim a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE unsafeNewWith #-}
+unsafeNewWith = G.replicate
+
+{-# DEPRECATED newWith, unsafeNewWith "Use replicate instead" #-}
+
index eceae52..fa1f4f7 100644 (file)
@@ -17,15 +17,18 @@ module Data.Vector.Storable.Mutable(
   MVector(..), IOVector, STVector, Storable,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, swap,
+  length, overlaps, slice, new, replicate, read, write, swap,
   clear, set, copy, grow,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
+  unsafeSlice, unsafeNew, unsafeRead, unsafeWrite, unsafeSwap,
   unsafeCopy, unsafeGrow,
 
   -- * Accessing the underlying memory
-  unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith
+  unsafeFromForeignPtr, unsafeToForeignPtr, unsafeWith,
+
+  -- * Deprecated operations
+  newWith, unsafeNewWith
 ) where
 
 import qualified Data.Vector.Generic.Mutable as G
@@ -39,7 +42,7 @@ import Foreign.C.Types ( CInt )
 
 import Control.Monad.Primitive
 
-import Prelude hiding( length, read )
+import Prelude hiding( length, replicate, read )
 
 import Data.Typeable ( Typeable )
 
@@ -131,13 +134,6 @@ unsafeNew :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE unsafeNew #-}
 unsafeNew = G.unsafeNew
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value. The length is not checked.
-unsafeNewWith :: (PrimMonad m, Storable a)
-                                => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE unsafeNewWith #-}
-unsafeNewWith = G.unsafeNewWith
-
 -- | Yield the element at the given position. No bounds checks are performed.
 unsafeRead :: (PrimMonad m, Storable a)
                                 => MVector (PrimState m) a -> Int -> m a
@@ -192,11 +188,11 @@ new :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE new #-}
 new = G.new
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value.
-newWith :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE newWith #-}
-newWith = G.newWith
+-- | Create a mutable vector of the given length (0 if the length is negative)
+-- and fill it with an initial value.
+replicate :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE replicate #-}
+replicate = G.replicate
 
 -- | Yield the element at the given position.
 read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
@@ -240,3 +236,16 @@ grow :: (PrimMonad m, Storable a)
 {-# INLINE grow #-}
 grow = G.grow
 
+
+-- | /DEPRECATED/ Use 'replicate' instead
+newWith :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE newWith #-}
+newWith = G.replicate
+
+-- | /DEPRECATED/ Use 'replicate' instead
+unsafeNewWith :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE unsafeNewWith #-}
+unsafeNewWith = G.replicate
+
+{-# DEPRECATED newWith, unsafeNewWith "Use replicate instead" #-}
+
index bb901ce..fed81cf 100644 (file)
@@ -15,21 +15,24 @@ module Data.Vector.Unboxed.Mutable (
   MVector(..), IOVector, STVector, Unbox,
 
   -- * Operations on mutable vectors
-  length, overlaps, slice, new, newWith, read, write, swap,
+  length, overlaps, slice, new, replicate, read, write, swap,
   clear, set, copy, grow,
   zip, zip3, zip4, zip5, zip6,
   unzip, unzip3, unzip4, unzip5, unzip6,
 
   -- * Unsafe operations
-  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite, unsafeSwap,
-  unsafeCopy, unsafeGrow
+  unsafeSlice, unsafeNew, unsafeRead, unsafeWrite, unsafeSwap,
+  unsafeCopy, unsafeGrow,
+
+  -- * Deprecated operations
+  newWith, unsafeNewWith
 ) where
 
 import Data.Vector.Unboxed.Base
 import qualified Data.Vector.Generic.Mutable as G
 import Control.Monad.Primitive
 
-import Prelude hiding ( zip, zip3, unzip, unzip3, length, read )
+import Prelude hiding ( zip, zip3, unzip, unzip3, length, replicate, read )
 
 #include "vector.h"
 
@@ -47,13 +50,6 @@ unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE unsafeNew #-}
 unsafeNew = G.unsafeNew
 
--- | Create a mutable vector of the given length and fill it with an
--- initial value. The length is not checked.
-unsafeNewWith :: (PrimMonad m, Unbox a)
-                                => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE unsafeNewWith #-}
-unsafeNewWith = G.unsafeNewWith
-
 -- | Yield the element at the given position. No bounds checks are performed.
 unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
 {-# INLINE unsafeRead #-}
@@ -108,9 +104,9 @@ new = G.new
 
 -- | Create a mutable vector of the given length and fill it with an
 -- initial value.
-newWith :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
-{-# INLINE newWith #-}
-newWith = G.newWith
+replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE replicate #-}
+replicate = G.replicate
 
 -- | Yield the element at the given position.
 read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
@@ -153,6 +149,20 @@ grow :: (PrimMonad m, Unbox a)
 {-# INLINE grow #-}
 grow = G.grow
 
+
+-- | /DEPRECATED/ Use 'replicate' instead
+newWith :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE newWith #-}
+newWith = G.replicate
+
+-- | /DEPRECATED/ Use 'replicate' instead
+unsafeNewWith :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
+{-# INLINE unsafeNewWith #-}
+unsafeNewWith = G.replicate
+
+{-# DEPRECATED newWith, unsafeNewWith "Use replicate instead" #-}
+
+
 #define DEFINE_MUTABLE
 #include "unbox-tuple-instances"