Add Unsafe prefix to constructor names

 - Since they are public and unsafe it makes sense to reflect this in name
 - This avoids name clashes with compatibility patterns

Author: Shimuuar

vector/src/Data/Vector.hs

@@ -198,14 +198,14 @@ import Prelude
 -- @since 0.12.2.0
 fromArray :: Array a -> Vector a
 {-# INLINE fromArray #-}
-fromArray arr = Vector 0 (sizeofArray arr) arr
+fromArray arr = UnsafeVector 0 (sizeofArray arr) arr
 
 -- | /O(n)/ Convert a vector to an array.
 --
 -- @since 0.12.2.0
 toArray :: Vector a -> Array a
 {-# INLINE toArray #-}
-toArray (Vector offset len arr)
+toArray (UnsafeVector offset len arr)
   | offset == 0 && len == sizeofArray arr = arr
   | otherwise = cloneArray arr offset len
 
@@ -218,7 +218,7 @@ toArray (Vector offset len arr)
 -- @since 0.13.0.0
 toArraySlice :: Vector a -> (Array a, Int, Int)
 {-# INLINE toArraySlice #-}
-toArraySlice (Vector offset len arr) = (arr, offset, len)
+toArraySlice (UnsafeVector offset len arr) = (arr, offset, len)
 
 
 -- Length information

vector/src/Data/Vector/Mutable.hs

@@ -84,7 +84,7 @@ import Prelude( Ord, Bool, Ordering(..), Int, Maybe, (<$>) )
 #include "vector.h"
 
 pattern MVector :: Int -> Int -> MutableArray s a -> MVector s a
-pattern MVector i j arr = U.MVector i j arr
+pattern MVector i j arr = U.UnsafeMVector i j arr
 {-# COMPLETE MVector #-}
 {-# DEPRECATED MVector "Use MVector exported from \"Data.Vector.Mutable.Unsafe\"" #-}
 

vector/src/Data/Vector/Mutable/Unsafe.hs

@@ -31,7 +31,7 @@ import Prelude
 type role MVector nominal representational
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
-data MVector s a = MVector
+data MVector s a = UnsafeMVector
   { unsafeOffset :: !Int -- ^ Offset in underlying array
   , unsafeSize   :: !Int -- ^ Size of slice
   , unsafeMutableArray  :: {-# UNPACK #-} !(MutableArray s a)
@@ -51,13 +51,13 @@ instance NFData a => NFData (MVector s a) where
 
 instance G.MVector MVector a where
   {-# INLINE basicLength #-}
-  basicLength (MVector _ n _) = n
+  basicLength (UnsafeMVector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice j m (MVector i _ arr) = MVector (i+j) m arr
+  basicUnsafeSlice j m (UnsafeMVector i _ arr) = UnsafeMVector (i+j) m arr
 
   {-# INLINE basicOverlaps #-}
-  basicOverlaps (MVector i m arr1) (MVector j n arr2)
+  basicOverlaps (UnsafeMVector i m arr1) (UnsafeMVector j n arr2)
     = sameMutableArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
@@ -67,7 +67,7 @@ instance G.MVector MVector a where
   basicUnsafeNew n
     = do
         arr <- newArray n uninitialised
-        return (MVector 0 n arr)
+        return (UnsafeMVector 0 n arr)
 
   {-# INLINE basicInitialize #-}
   -- initialization is unnecessary for boxed vectors
@@ -77,19 +77,19 @@ instance G.MVector MVector a where
   basicUnsafeReplicate n x
     = do
         arr <- newArray n x
-        return (MVector 0 n arr)
+        return (UnsafeMVector 0 n arr)
 
   {-# INLINE basicUnsafeRead #-}
-  basicUnsafeRead (MVector i _ arr) j = readArray arr (i+j)
+  basicUnsafeRead (UnsafeMVector i _ arr) j = readArray arr (i+j)
 
   {-# INLINE basicUnsafeWrite #-}
-  basicUnsafeWrite (MVector i _ arr) j x = writeArray arr (i+j) x
+  basicUnsafeWrite (UnsafeMVector i _ arr) j x = writeArray arr (i+j) x
 
   {-# INLINE basicUnsafeCopy #-}
-  basicUnsafeCopy (MVector i n dst) (MVector j _ src)
+  basicUnsafeCopy (UnsafeMVector i n dst) (UnsafeMVector j _ src)
     = copyMutableArray dst i src j n
 
-  basicUnsafeMove dst@(MVector iDst n arrDst) src@(MVector iSrc _ arrSrc)
+  basicUnsafeMove dst@(UnsafeMVector iDst n arrDst) src@(UnsafeMVector iSrc _ arrSrc)
     = case n of
         0 -> return ()
         1 -> readArray arrSrc iSrc >>= writeArray arrDst iDst

vector/src/Data/Vector/Primitive.hs

@@ -179,7 +179,7 @@ import Prelude
   , (==))
 
 pattern Vector :: Int -> Int -> ByteArray -> Vector a
-pattern Vector i j arr = U.Vector i j arr
+pattern Vector i j arr = U.UnsafeVector i j arr
 {-# COMPLETE Vector #-}
 {-# DEPRECATED Vector "Use Vector constructor exported from \"Data.Vector.Primitive.Unsafe\"" #-}
 

vector/src/Data/Vector/Primitive/Mutable.hs

@@ -85,7 +85,7 @@ import Prelude ( Ord, Bool, Int, Maybe, Ordering(..) )
 
 
 pattern MVector :: Int -> Int -> MutableByteArray s -> MVector s a
-pattern MVector i j arr = U.MVector i j arr
+pattern MVector i j arr = U.UnsafeMVector i j arr
 {-# COMPLETE MVector #-}
 {-# DEPRECATED MVector "Use MVector exported from \"Data.Vector.Primitive.Mutable.Unsafe\"" #-}
 

vector/src/Data/Vector/Primitive/Mutable/Unsafe.hs

@@ -43,7 +43,7 @@ import Unsafe.Coerce
 type role MVector nominal nominal
 
 -- | Mutable vectors of primitive types.
-data MVector s a = MVector
+data MVector s a = UnsafeMVector
   { unsafeOffset :: !Int
     -- ^ Offset into the `unsafeMutableByteArray` in number of elements, not bytes
   , unsafeSize :: !Int
@@ -71,25 +71,25 @@ unsafeCoerceMVector = unsafeCoerce
 -- | @since 0.13.0.0
 unsafeCast :: forall a b s. (HasCallStack, Prim a, Prim b) => MVector s a -> MVector s b
 {-# INLINE unsafeCast #-}
-unsafeCast (MVector o n ba)
-  | sizeOf (undefined :: a) == sizeOf (undefined :: b) = MVector o n ba
+unsafeCast (UnsafeMVector o n ba)
+  | sizeOf (undefined :: a) == sizeOf (undefined :: b) = UnsafeMVector o n ba
   | otherwise = error "Element size mismatch"
 
 
 
 instance NFData (MVector s a) where
-  rnf (MVector _ _ _) = ()
+  rnf (UnsafeMVector _ _ _) = ()
 
 instance NFData1 (MVector s) where
-  liftRnf _ (MVector _ _ _) = ()
+  liftRnf _ (UnsafeMVector _ _ _) = ()
 
 instance Prim a => MG.MVector MVector a where
-  basicLength (MVector _ n _) = n
-  basicUnsafeSlice j m (MVector i _ arr)
-    = MVector (i+j) m arr
+  basicLength (UnsafeMVector _ n _) = n
+  basicUnsafeSlice j m (UnsafeMVector i _ arr)
+    = UnsafeMVector (i+j) m arr
 
   {-# INLINE basicOverlaps #-}
-  basicOverlaps (MVector i m arr1) (MVector j n arr2)
+  basicOverlaps (UnsafeMVector i m arr1) (UnsafeMVector j n arr2)
     = sameMutableByteArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
@@ -99,36 +99,36 @@ instance Prim a => MG.MVector MVector a where
   basicUnsafeNew n
     | n < 0 = error $ "Primitive.basicUnsafeNew: negative length: " ++ show n
     | n > mx = error $ "Primitive.basicUnsafeNew: length too large: " ++ show n
-    | otherwise = MVector 0 n `liftM` newByteArray (n * size)
+    | otherwise = UnsafeMVector 0 n `liftM` newByteArray (n * size)
     where
       size = sizeOf (undefined :: a)
       mx = maxBound `div` size :: Int
 
   {-# INLINE basicInitialize #-}
-  basicInitialize (MVector off n v) =
+  basicInitialize (UnsafeMVector off n v) =
       setByteArray v (off * size) (n * size) (0 :: Word8)
     where
       size = sizeOf (undefined :: a)
 
 
   {-# INLINE basicUnsafeRead #-}
-  basicUnsafeRead (MVector i _ arr) j = readByteArray arr (i+j)
+  basicUnsafeRead (UnsafeMVector i _ arr) j = readByteArray arr (i+j)
 
   {-# INLINE basicUnsafeWrite #-}
-  basicUnsafeWrite (MVector i _ arr) j x = writeByteArray arr (i+j) x
+  basicUnsafeWrite (UnsafeMVector i _ arr) j x = writeByteArray arr (i+j) x
 
   {-# INLINE basicUnsafeCopy #-}
-  basicUnsafeCopy (MVector i n dst) (MVector j _ src)
+  basicUnsafeCopy (UnsafeMVector i n dst) (UnsafeMVector j _ src)
     = copyMutableByteArray dst (i*sz) src (j*sz) (n*sz)
     where
       sz = sizeOf (undefined :: a)
 
   {-# INLINE basicUnsafeMove #-}
-  basicUnsafeMove (MVector i n dst) (MVector j _ src)
+  basicUnsafeMove (UnsafeMVector i n dst) (UnsafeMVector j _ src)
     = moveByteArray dst (i*sz) src (j*sz) (n * sz)
     where
       sz = sizeOf (undefined :: a)
 
   {-# INLINE basicSet #-}
-  basicSet (MVector i n arr) x = setByteArray arr i n x
+  basicSet (UnsafeMVector i n arr) x = setByteArray arr i n x
 

vector/src/Data/Vector/Primitive/Unsafe.hs

@@ -48,7 +48,7 @@ import Data.Vector.Primitive.Mutable.Unsafe (MVector(..))
 type role Vector nominal
 
 -- | Unboxed vectors of primitive types.
-data Vector a = Vector
+data Vector a = UnsafeVector
   { unsafeOffset :: !Int
     -- ^ Offset into `unsafeByteArray` in number of elements, not bytes
   , unsafeSize :: !Int
@@ -79,31 +79,31 @@ unsafeCoerceVector = unsafeCoerce
 -- | @since 0.13.0.0
 unsafeCast :: forall a b. (HasCallStack, Prim a, Prim b) => Vector a -> Vector b
 {-# INLINE unsafeCast #-}
-unsafeCast (Vector o n ba)
-  | sizeOf (undefined :: a) == sizeOf (undefined :: b) = Vector o n ba
+unsafeCast (UnsafeVector o n ba)
+  | sizeOf (undefined :: a) == sizeOf (undefined :: b) = UnsafeVector o n ba
   | otherwise = error "Element size mismatch"
 
 
 instance Prim a => G.Vector Vector a where
   {-# INLINE basicUnsafeFreeze #-}
-  basicUnsafeFreeze (MVector i n marr)
-    = Vector i n `liftM` unsafeFreezeByteArray marr
+  basicUnsafeFreeze (UnsafeMVector i n marr)
+    = UnsafeVector i n `liftM` unsafeFreezeByteArray marr
 
   {-# INLINE basicUnsafeThaw #-}
-  basicUnsafeThaw (Vector i n arr)
-    = MVector i n `liftM` unsafeThawByteArray arr
+  basicUnsafeThaw (UnsafeVector i n arr)
+    = UnsafeMVector i n `liftM` unsafeThawByteArray arr
 
   {-# INLINE basicLength #-}
-  basicLength (Vector _ n _) = n
+  basicLength (UnsafeVector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
+  basicUnsafeSlice j n (UnsafeVector i _ arr) = UnsafeVector (i+j) n arr
 
   {-# INLINE basicUnsafeIndexM #-}
-  basicUnsafeIndexM (Vector i _ arr) j = return $! indexByteArray arr (i+j)
+  basicUnsafeIndexM (UnsafeVector i _ arr) j = return $! indexByteArray arr (i+j)
 
   {-# INLINE basicUnsafeCopy #-}
-  basicUnsafeCopy (MVector i n dst) (Vector j _ src)
+  basicUnsafeCopy (UnsafeMVector i n dst) (UnsafeVector j _ src)
     = copyByteArray dst (i*sz) src (j*sz) (n*sz)
     where
       sz = sizeOf (undefined :: a)
@@ -113,11 +113,11 @@ instance Prim a => G.Vector Vector a where
 
 
 instance NFData (Vector a) where
-  rnf (Vector _ _ _) = ()
+  rnf (UnsafeVector _ _ _) = ()
 
 -- | @since 0.12.1.0
 instance NFData1 Vector where
-  liftRnf _ (Vector _ _ _) = ()
+  liftRnf _ (UnsafeVector _ _ _) = ()
 
 instance (Show a, Prim a) => Show (Vector a) where
   showsPrec = G.showsPrec

vector/src/Data/Vector/Storable.hs

@@ -911,7 +911,7 @@ izipWith6 = G.izipWith6
 -- True
 isSameVector :: (Storable a) => Vector a -> Vector a -> Bool
 {-# INLINE isSameVector #-}
-isSameVector (Vector n1 ptr1) (Vector n2 ptr2) = n1 == n2 && ptr1 == ptr2
+isSameVector (UnsafeVector n1 ptr1) (UnsafeVector n2 ptr2) = n1 == n2 && ptr1 == ptr2
 
 
 -- Monadic zipping
@@ -1896,9 +1896,9 @@ iforA_ = G.iforA_
 -- underlying memory block.
 unsafeCast :: forall a b. (Storable a, Storable b) => Vector a -> Vector b
 {-# INLINE unsafeCast #-}
-unsafeCast (Vector n fp)
-  = Vector ((n * sizeOf (undefined :: a)) `div` sizeOf (undefined :: b))
-           (castForeignPtr fp)
+unsafeCast (UnsafeVector n fp)
+  = UnsafeVector ((n * sizeOf (undefined :: a)) `div` sizeOf (undefined :: b))
+                 (castForeignPtr fp)
 
 -- Conversions - Mutable vectors
 -- -----------------------------

vector/src/Data/Vector/Storable/Mutable.hs

@@ -94,7 +94,7 @@ import Prelude (Int, Ord, Bool, Maybe, Ordering(..) )
 
 
 pattern MVector :: Int -> ForeignPtr a -> MVector s a
-pattern MVector i ptr = U.MVector i ptr
+pattern MVector i ptr = U.UnsafeMVector i ptr
 {-# COMPLETE MVector #-}
 {-# DEPRECATED MVector "Use MVector exported from Data.Vector.Strict.Mutable.Unsafe" #-}