Clean up interface to mutable vectors
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 6 Dec 2009 05:38:21 +0000 (05:38 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 6 Dec 2009 05:38:21 +0000 (05:38 +0000)
Data/Vector/Generic/Mutable.hs
Data/Vector/Mutable.hs
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable/Mutable.hs
Data/Vector/Unboxed/Unbox.hs
internal/GenUnboxTuple.hs
internal/unbox-tuple-instances

index bf70aaf..d22c5ab 100644 (file)
 --
 
 module Data.Vector.Generic.Mutable (
 --
 
 module Data.Vector.Generic.Mutable (
+  -- * Class of mutable vector types
   MVector(..),
 
   MVector(..),
 
-  slice, new, newWith, read, write, copy, grow,
-  unstream, transform,
-  accum, update, reverse
+  -- * Operations on mutable vectors
+  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+
+  -- * Unsafe operations
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeCopy, unsafeGrow,
+
+  -- * Internal operations
+  unstream, transform, accum, update, reverse
 ) where
 
 import qualified Data.Vector.Fusion.Stream      as Stream
 ) where
 
 import qualified Data.Vector.Fusion.Stream      as Stream
@@ -40,123 +47,209 @@ gROWTH_FACTOR = 1.5
 -- | Class of mutable vectors parametrised with a primitive state token.
 --
 class MVector v a where
 -- | Class of mutable vectors parametrised with a primitive state token.
 --
 class MVector v a where
-  -- | Length of the mutable vector
-  length           :: v s a -> Int
+  -- | Length of the mutable vector. This method should not be
+  -- called directly, use 'length' instead.
+  basicLength       :: v s a -> Int
 
 
-  -- | Yield a part of the mutable vector without copying it. No range checks!
-  unsafeSlice      :: v s a -> Int  -- ^ starting index
+  -- | Yield a part of the mutable vector without copying it. This method
+  -- should not be called directly, use 'unsafeSlice' instead.
+  basicUnsafeSlice :: v s a -> Int  -- ^ starting index
                             -> Int  -- ^ length of the slice
                             -> v s a
 
                             -> Int  -- ^ length of the slice
                             -> v s a
 
-  -- Check whether two vectors overlap.
-  overlaps         :: v s a -> v s a -> Bool
+  -- Check whether two vectors overlap. This method should not be
+  -- called directly, use 'overlaps' instead.
+  basicOverlaps    :: v s a -> v s a -> Bool
 
 
-  -- | Create a mutable vector of the given length. Length is not checked!
-  unsafeNew        :: PrimMonad m => Int -> m (v (PrimState m) a)
+  -- | Create a mutable vector of the given length. This method should not be
+  -- called directly, use 'unsafeNew' instead.
+  basicUnsafeNew   :: PrimMonad m => Int -> m (v (PrimState m) a)
 
   -- | Create a mutable vector of the given length and fill it with an
 
   -- | Create a mutable vector of the given length and fill it with an
-  -- initial value. Length is not checked!
-  unsafeNewWith    :: PrimMonad m => Int -> a -> m (v (PrimState m) a)
-
-  -- | Yield the element at the given position. Index is not checked!
-  unsafeRead       :: PrimMonad m => v (PrimState m) a -> Int -> m a
-
-  -- | Replace the element at the given position. Index is not checked!
-  unsafeWrite      :: PrimMonad m => v (PrimState m) a -> Int -> a -> m ()
-
-  -- | Clear all references to external objects
-  clear            :: PrimMonad m => v (PrimState m) a -> m ()
-
-  -- | Write the value at each position.
-  set              :: PrimMonad m => v (PrimState m) a -> a -> m ()
-
-  -- | Copy a vector. The two vectors may not overlap. This is not checked!
-  unsafeCopy       :: PrimMonad m => v (PrimState m) a   -- ^ target
+  -- initial value. This method should not be called directly, use
+  -- 'unsafeNewWith' instead.
+  basicUnsafeNewWith :: 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.
+  basicUnsafeRead  :: PrimMonad m => v (PrimState m) a -> Int -> m a
+
+  -- | Replace the element at the given position. This method should not be
+  -- called directly, use 'unsafeWrite' instead.
+  basicUnsafeWrite :: PrimMonad m => v (PrimState m) a -> Int -> a -> m ()
+
+  -- | Reset all elements of the vector to some undefined value, clearing all
+  -- references to external objects. This is usually a noop for unboxed
+  -- vectors. This method should not be called directly, use 'clear' instead.
+  basicClear       :: PrimMonad m => v (PrimState m) a -> m ()
+
+  -- | Set all elements of the vector to the given value. This method should
+  -- not be called directly, use 'set' instead.
+  basicSet         :: PrimMonad m => v (PrimState m) a -> a -> m ()
+
+  -- | Copy a vector. The two vectors may not overlap. This method should not
+  -- be called directly, use 'unsafeCopy' instead.
+  basicUnsafeCopy  :: PrimMonad m => v (PrimState m) a   -- ^ target
                                   -> v (PrimState m) a   -- ^ source
                                   -> m ()
 
                                   -> v (PrimState m) a   -- ^ source
                                   -> m ()
 
-  -- | Grow a vector by the given number of elements. The length is not
-  -- checked!
-  unsafeGrow :: PrimMonad m => v (PrimState m) a -> Int -> m (v (PrimState m) a)
-
-  {-# INLINE unsafeNewWith #-}
-  unsafeNewWith n x = UNSAFE_CHECK(checkLength) "unsafeNewWith" n
-                    $ do
-                        v <- unsafeNew n
-                        set v x
-                        return v
-
-  {-# INLINE set #-}
-  set v x = do_set 0
+  -- | Grow a vector by the given number of elements. This method should not be
+  -- called directly, use 'unsafeGrow' instead.
+  basicUnsafeGrow  :: PrimMonad m => v (PrimState m) a -> Int
+                                                       -> m (v (PrimState m) a)
+  {-# INLINE basicUnsafeNewWith #-}
+  basicUnsafeNewWith n x
+    = do
+        v <- basicUnsafeNew n
+        set v x
+        return v
+
+  {-# INLINE basicClear #-}
+  basicClear _ = return ()
+
+  {-# INLINE basicSet #-}
+  basicSet v x = do_set 0
     where
       n = length v
 
       do_set i | i < n = do
     where
       n = length v
 
       do_set i | i < n = do
-                            unsafeWrite v i x
-                            do_set (i+1)
+                           basicUnsafeWrite v i x
+                           do_set (i+1)
                 | otherwise = return ()
 
                 | otherwise = return ()
 
-  {-# INLINE unsafeCopy #-}
-  unsafeCopy dst src
-    = UNSAFE_CHECK(check) "unsafeCopy" "overlapping vectors"
-                                          (not (dst `overlaps` src))
-    $ UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
-                                          (length dst == length src)
-    $ do_copy 0
+  {-# INLINE basicUnsafeCopy #-}
+  basicUnsafeCopy dst src = do_copy 0
     where
       n = length src
 
       do_copy i | i < n = do
     where
       n = length src
 
       do_copy i | i < n = do
-                            x <- unsafeRead src i
-                            unsafeWrite dst i x
+                            x <- basicUnsafeRead src i
+                            basicUnsafeWrite dst i x
                             do_copy (i+1)
                 | otherwise = return ()
 
                             do_copy (i+1)
                 | otherwise = return ()
 
-  {-# INLINE unsafeGrow #-}
-  unsafeGrow v by = UNSAFE_CHECK(checkLength) "unsafeGrow" by
-                  $ do
-                      v' <- unsafeNew (n+by)
-                      unsafeCopy (unsafeSlice v' 0 n) v
-                      return v'
+  {-# INLINE basicUnsafeGrow #-}
+  basicUnsafeGrow v by
+    = do
+        v' <- basicUnsafeNew (n+by)
+        basicUnsafeCopy (basicUnsafeSlice v' 0 n) v
+        return v'
     where
       n = length v
 
     where
       n = length v
 
--- | Yield a part of the mutable vector without copying it. Safer version of
--- 'unsafeSlice'.
+
+
+-- | Yield a part of the mutable vector without copying it. No bounds checks
+-- are performed.
+unsafeSlice :: MVector v a => v s a -> Int  -- ^ starting index
+                                    -> Int  -- ^ length of the slice
+                                    -> v s a
+{-# INLINE unsafeSlice #-}
+unsafeSlice v i n = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
+                  $ basicUnsafeSlice v i n
+
+
+-- | 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.
+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
+
+-- | Yield the element at the given position. No bounds checks are performed.
+unsafeRead :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
+{-# INLINE unsafeRead #-}
+unsafeRead v i = UNSAFE_CHECK(checkIndex) "unsafeRead" i (length v)
+               $ basicUnsafeRead v i
+
+-- | Replace the element at the given position. No bounds checks are performed.
+unsafeWrite :: (PrimMonad m, MVector v a)
+                                => v (PrimState m) a -> Int -> a -> m ()
+{-# INLINE unsafeWrite #-}
+unsafeWrite v i x = UNSAFE_CHECK(checkIndex) "unsafeWrite" i (length v)
+                  $ basicUnsafeWrite v i x
+
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap. This is not checked.
+unsafeCopy :: (PrimMonad m, MVector v a) => v (PrimState m) a   -- ^ target
+                                         -> v (PrimState m) a   -- ^ source
+                                         -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
+                                         (length dst == length src)
+                   $ UNSAFE_CHECK(check) "unsafeCopy" "overlapping vectors"
+                                         (not (dst `overlaps` src))
+                   $ basicUnsafeCopy dst src
+
+-- | Grow a vector by the given number of elements. The number must be
+-- positive but this is not checked.
+unsafeGrow :: (PrimMonad m, MVector v a)
+                        => v (PrimState m) a -> Int -> m (v (PrimState m) a)
+{-# INLINE unsafeGrow #-}
+unsafeGrow v n = UNSAFE_CHECK(checkLength) "unsafeGrow" n
+               $ basicUnsafeGrow v n
+
+-- | Length of the mutable vector.
+length :: MVector v a => v s a -> Int
+{-# INLINE length #-}
+length = basicLength
+
+-- Check whether two vectors overlap.
+overlaps :: MVector v a => v s a -> v s a -> Bool
+{-# INLINE overlaps #-}
+overlaps = basicOverlaps
+
+-- | Yield a part of the mutable vector without copying it.
 slice :: MVector v a => v s a -> Int -> Int -> v s a
 {-# INLINE slice #-}
 slice v i n = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
             $ unsafeSlice v i n
 
 slice :: MVector v a => v s a -> Int -> Int -> v s a
 {-# INLINE slice #-}
 slice v i n = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
             $ unsafeSlice v i n
 
--- | Create a mutable vector of the given length. Safer version of
--- 'unsafeNew'.
+-- | Create a mutable vector of the given length.
 new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
 {-# INLINE new #-}
 new n = BOUNDS_CHECK(checkLength) "new" n
       $ unsafeNew n
 
 -- | Create a mutable vector of the given length and fill it with an
 new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
 {-# INLINE new #-}
 new n = BOUNDS_CHECK(checkLength) "new" n
       $ unsafeNew n
 
 -- | Create a mutable vector of the given length and fill it with an
--- initial value. Safer version of 'unsafeNewWith'.
+-- 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
 
 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
 
--- | Yield the element at the given position. Safer version of 'unsafeRead'.
+-- | Yield the element at the given position.
 read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
 {-# INLINE read #-}
 read v i = BOUNDS_CHECK(checkIndex) "read" i (length v)
          $ unsafeRead v i
 
 read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a
 {-# INLINE read #-}
 read v i = BOUNDS_CHECK(checkIndex) "read" i (length v)
          $ unsafeRead v i
 
--- | Replace the element at the given position. Safer version of
--- 'unsafeWrite'.
+-- | Replace the element at the given position.
 write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
 {-# INLINE write #-}
 write v i x = BOUNDS_CHECK(checkIndex) "write" i (length v)
             $ unsafeWrite v i x
 
 write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m ()
 {-# INLINE write #-}
 write v i x = BOUNDS_CHECK(checkIndex) "write" i (length v)
             $ unsafeWrite v i x
 
--- | Copy a vector. The two vectors may not overlap. Safer version of
--- 'unsafeCopy'.
+-- | 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 v a) => v (PrimState m) a -> m ()
+{-# INLINE clear #-}
+clear = basicClear
+
+-- | Set all elements of the vector to the given value.
+set :: (PrimMonad m, MVector v a) => v (PrimState m) a -> a -> m ()
+{-# INLINE set #-}
+set = basicSet
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap.
 copy :: (PrimMonad m, MVector v a)
                 => v (PrimState m) a -> v (PrimState m) a -> m ()
 {-# INLINE copy #-}
 copy :: (PrimMonad m, MVector v a)
                 => v (PrimState m) a -> v (PrimState m) a -> m ()
 {-# INLINE copy #-}
@@ -166,8 +259,8 @@ copy dst src = BOUNDS_CHECK(check) "copy" "overlapping vectors"
                                           (length dst == length src)
              $ unsafeCopy dst src
 
                                           (length dst == length src)
              $ unsafeCopy dst src
 
--- | Grow a vector by the given number of elements. Safer version of
--- 'unsafeGrow'.
+-- | Grow a vector by the given number of elements. The number must be
+-- positive.
 grow :: (PrimMonad m, MVector v a)
                 => v (PrimState m) a -> Int -> m (v (PrimState m) a)
 {-# INLINE grow #-}
 grow :: (PrimMonad m, MVector v a)
                 => v (PrimState m) a -> Int -> m (v (PrimState m) a)
 {-# INLINE grow #-}
index 5851a74..93e5de1 100644 (file)
 -- Mutable boxed vectors.
 --
 
 -- Mutable boxed vectors.
 --
 
-module Data.Vector.Mutable ( MVector(..), IOVector, STVector )
-where
+module Data.Vector.Mutable (
+  -- * Mutable boxed vectors
+  MVector(..), IOVector, STVector,
+
+  -- * Operations on mutable vectors
+  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+
+  -- * Unsafe operations
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeCopy, unsafeGrow
+) where
 
 import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.Array
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
 
 
 import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.Array
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
 
+import Prelude hiding ( length, read )
+
 #include "vector.h"
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
 #include "vector.h"
 
 -- | Mutable boxed vectors keyed on the monad they live in ('IO' or @'ST' s@).
@@ -31,41 +42,147 @@ type IOVector = MVector RealWorld
 type STVector s = MVector s
 
 instance G.MVector MVector a where
 type STVector s = MVector s
 
 instance G.MVector MVector a where
-  length (MVector _ n _) = n
-  unsafeSlice (MVector i n arr) j m
-    = UNSAFE_CHECK(checkSlice) "unsafeSlice" j m n
-    $ MVector (i+j) m arr
+  {-# INLINE basicLength #-}
+  basicLength (MVector _ n _) = n
 
 
-  {-# INLINE overlaps #-}
-  overlaps (MVector i m arr1) (MVector j n arr2)
+  {-# INLINE basicUnsafeSlice #-}
+  basicUnsafeSlice (MVector i n arr) j m = MVector (i+j) m arr
+
+  {-# INLINE basicOverlaps #-}
+  basicOverlaps (MVector i m arr1) (MVector j n arr2)
     = sameMutableArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
     = sameMutableArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
-  {-# INLINE unsafeNew #-}
-  unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
-              $ do
-                  arr <- newArray n uninitialised
-                  return (MVector 0 n arr)
+  {-# INLINE basicUnsafeNew #-}
+  basicUnsafeNew n
+    = do
+        arr <- newArray n uninitialised
+        return (MVector 0 n arr)
 
 
-  {-# INLINE unsafeNewWith #-}
-  unsafeNewWith n x = UNSAFE_CHECK(checkLength) "unsafeNewWith" n
-                    $ do
-                        arr <- newArray n x
-                        return (MVector 0 n arr)
+  {-# INLINE basicUnsafeNewWith #-}
+  basicUnsafeNewWith n x
+    = do
+        arr <- newArray n x
+        return (MVector 0 n arr)
 
 
-  {-# INLINE unsafeRead #-}
-  unsafeRead (MVector i n arr) j = UNSAFE_CHECK(checkIndex) "unsafeRead" j n
-                                 $ readArray arr (i+j)
+  {-# INLINE basicUnsafeRead #-}
+  basicUnsafeRead (MVector i n arr) j = readArray arr (i+j)
 
 
-  {-# INLINE unsafeWrite #-}
-  unsafeWrite (MVector i n arr) j x = UNSAFE_CHECK(checkIndex) "unsafeWrite" j n
-                                    $ writeArray arr (i+j) x
+  {-# INLINE basicUnsafeWrite #-}
+  basicUnsafeWrite (MVector i n arr) j x = writeArray arr (i+j) x
 
 
-  {-# INLINE clear #-}
-  clear v = G.set v uninitialised
+  {-# INLINE basicClear #-}
+  basicClear v = G.set v uninitialised
 
 uninitialised :: a
 uninitialised = error "Data.Vector.Mutable: uninitialised element"
 
 
 uninitialised :: a
 uninitialised = error "Data.Vector.Mutable: uninitialised element"
 
+
+-- | Yield a part of the mutable vector without copying it. No bounds checks
+-- are performed.
+unsafeSlice :: MVector s a -> Int  -- ^ starting index
+                           -> Int  -- ^ length of the slice
+                           -> MVector s a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
+
+-- | Create a mutable vector of the given length. The length is not checked.
+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 #-}
+unsafeRead = G.unsafeRead
+
+-- | Replace the element at the given position. No bounds checks are performed.
+unsafeWrite :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE unsafeWrite #-}
+unsafeWrite = G.unsafeWrite
+
+-- | 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
+                          -> MVector (PrimState m) a   -- ^ source
+                          -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+
+-- | Grow a vector by the given number of elements. The number must be
+-- positive but this is not checked.
+unsafeGrow :: PrimMonad m
+               => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE unsafeGrow #-}
+unsafeGrow = G.unsafeGrow
+
+-- | Length of the mutable vector.
+length :: MVector s a -> Int
+{-# INLINE length #-}
+length = G.length
+
+-- Check whether two vectors overlap.
+overlaps :: MVector s a -> MVector s a -> Bool
+{-# INLINE overlaps #-}
+overlaps = G.overlaps
+
+-- | Yield a part of the mutable vector without copying it.
+slice :: MVector s a -> Int -> Int -> MVector s a
+{-# INLINE slice #-}
+slice = G.slice
+
+-- | Create a mutable vector of the given length.
+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
+
+-- | Yield the element at the given position.
+read :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
+{-# INLINE read #-}
+read = G.read
+
+-- | Replace the element at the given position.
+write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE write #-}
+write = G.write
+
+-- | 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 ()
+{-# INLINE clear #-}
+clear = G.clear
+
+-- | Set all elements of the vector to the given value.
+set :: PrimMonad m => MVector (PrimState m) a -> a -> m ()
+{-# INLINE set #-}
+set = G.set
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap.
+copy :: PrimMonad m
+                 => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
+
+-- | Grow a vector by the given number of elements. The number must be
+-- positive.
+grow :: PrimMonad m
+              => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE grow #-}
+grow = G.grow
+
index 7382c31..06a4321 100644 (file)
 -- Mutable primitive vectors.
 --
 
 -- Mutable primitive vectors.
 --
 
-module Data.Vector.Primitive.Mutable ( MVector(..), IOVector, STVector )
-where
+module Data.Vector.Primitive.Mutable (
+  -- * Mutable vectors of primitive types
+  MVector(..), IOVector, STVector, Prim,
+
+  -- * Operations on mutable vectors
+  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+
+  -- * Unsafe operations
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeCopy, unsafeGrow
+) where
 
 import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
 
 import qualified Data.Vector.Generic.Mutable as G
 import           Data.Primitive.ByteArray
 import           Data.Primitive ( Prim, sizeOf )
 import           Control.Monad.Primitive
 import           Control.Monad.ST ( ST )
+import           Control.Monad ( liftM )
+
+import Prelude hiding( length, read )
 
 #include "vector.h"
 
 
 #include "vector.h"
 
--- | Mutable unboxed vectors. They live in the 'ST' monad.
+-- | Mutable vectors of primitive types.
 data MVector s a = MVector {-# UNPACK #-} !Int
                            {-# UNPACK #-} !Int
                            {-# UNPACK #-} !(MutableByteArray s)
 data MVector s a = MVector {-# UNPACK #-} !Int
                            {-# UNPACK #-} !Int
                            {-# UNPACK #-} !(MutableByteArray s)
@@ -33,31 +45,133 @@ type IOVector = MVector RealWorld
 type STVector s = MVector s
 
 instance Prim a => G.MVector MVector a where
 type STVector s = MVector s
 
 instance Prim a => G.MVector MVector a where
-  length (MVector _ n _) = n
-  unsafeSlice (MVector i n arr) j m
-    = UNSAFE_CHECK(checkSlice) "unsafeSlice" j m n
-    $ MVector (i+j) m arr
+  basicLength (MVector _ n _) = n
+  basicUnsafeSlice (MVector i n arr) j m
+    = MVector (i+j) m arr
 
 
-  {-# INLINE overlaps #-}
-  overlaps (MVector i m arr1) (MVector j n arr2)
+  {-# INLINE basicOverlaps #-}
+  basicOverlaps (MVector i m arr1) (MVector j n arr2)
     = sameMutableByteArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
     = sameMutableByteArray arr1 arr2
       && (between i j (j+n) || between j i (i+m))
     where
       between x y z = x >= y && x < z
 
-  {-# INLINE unsafeNew #-}
-  unsafeNew n = do
-                  arr <- newByteArray (n * sizeOf (undefined :: a))
-                  return (MVector 0 n arr)
+  {-# INLINE basicUnsafeNew #-}
+  basicUnsafeNew n = MVector 0 n
+                     `liftM` newByteArray (n * sizeOf (undefined :: a))
+
+  {-# INLINE basicUnsafeRead #-}
+  basicUnsafeRead (MVector i n arr) j = readByteArray arr (i+j)
+
+  {-# INLINE basicUnsafeWrite #-}
+  basicUnsafeWrite (MVector i n arr) j x = writeByteArray arr (i+j) x
+
+-- | Yield a part of the mutable vector without copying it. No bounds checks
+-- are performed.
+unsafeSlice :: Prim a => MVector s a -> Int  -- ^ starting index
+                                     -> Int  -- ^ length of the slice
+                                     -> MVector s a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
+
+-- | Create a mutable vector of the given length. The length is not checked.
+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 #-}
+unsafeRead = G.unsafeRead
+
+-- | Replace the element at the given position. No bounds checks are performed.
+unsafeWrite :: (PrimMonad m, Prim a)
+                                => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE unsafeWrite #-}
+unsafeWrite = G.unsafeWrite
+
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap. This is not checked.
+unsafeCopy :: (PrimMonad m, Prim a) => MVector (PrimState m) a   -- ^ target
+                                    -> MVector (PrimState m) a   -- ^ source
+                                    -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+
+-- | Grow a vector by the given number of elements. The number must be
+-- positive but this is not checked.
+unsafeGrow :: (PrimMonad m, Prim a)
+               => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE unsafeGrow #-}
+unsafeGrow = G.unsafeGrow
+
+-- | Length of the mutable vector.
+length :: Prim a => MVector s a -> Int
+{-# INLINE length #-}
+length = G.length
+
+-- Check whether two vectors overlap.
+overlaps :: Prim a => MVector s a -> MVector s a -> Bool
+{-# INLINE overlaps #-}
+overlaps = G.overlaps
+
+-- | Yield a part of the mutable vector without copying it.
+slice :: Prim a => MVector s a -> Int -> Int -> MVector s a
+{-# INLINE slice #-}
+slice = G.slice
+
+-- | Create a mutable vector of the given length.
+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
+
+-- | Yield the element at the given position.
+read :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> m a
+{-# INLINE read #-}
+read = G.read
+
+-- | Replace the element at the given position.
+write :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE write #-}
+write = G.write
+
+-- | 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 ()
+{-# INLINE clear #-}
+clear = G.clear
 
 
-  {-# INLINE unsafeRead #-}
-  unsafeRead (MVector i n arr) j = UNSAFE_CHECK(checkIndex) "unsafeRead" j n
-                                 $ readByteArray arr (i+j)
+-- | Set all elements of the vector to the given value.
+set :: (PrimMonad m, Prim a) => MVector (PrimState m) a -> a -> m ()
+{-# INLINE set #-}
+set = G.set
 
 
-  {-# INLINE unsafeWrite #-}
-  unsafeWrite (MVector i n arr) j x = UNSAFE_CHECK(checkIndex) "unsafeWrite" j n
-                                    $ writeByteArray arr (i+j) x
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap.
+copy :: (PrimMonad m, Prim a)
+                => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
 
 
-  {-# INLINE clear #-}
-  clear _ = return ()
+-- | Grow a vector by the given number of elements. The number must be
+-- positive.
+grow :: (PrimMonad m, Prim a)
+              => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE grow #-}
+grow = G.grow
 
 
index 4366bd1..5b0d9d2 100644 (file)
 -- Mutable vectors based on Storable.
 --
 
 -- Mutable vectors based on Storable.
 --
 
-module Data.Vector.Storable.Mutable( MVector(..) )
-where
+module Data.Vector.Storable.Mutable(
+  -- * Mutable vectors of 'Storable' types
+  MVector(..), IOVector, STVector, Storable,
+
+  -- * Operations on mutable vectors
+  length, overlaps, slice, new, newWith, read, write, clear, set, copy, grow,
+
+  -- * Unsafe operations
+  unsafeSlice, unsafeNew, unsafeNewWith, unsafeRead, unsafeWrite,
+  unsafeCopy, unsafeGrow
+) where
 
 import qualified Data.Vector.Generic.Mutable as G
 
 import Foreign.Storable
 import Foreign.ForeignPtr
 
 
 import qualified Data.Vector.Generic.Mutable as G
 
 import Foreign.Storable
 import Foreign.ForeignPtr
 
-import Control.Monad.Primitive ( unsafePrimToPrim )
+import Control.Monad.Primitive
+
+import Prelude hiding( length, read )
 
 #include "vector.h"
 
 
 #include "vector.h"
 
@@ -29,37 +40,145 @@ data MVector s a = MVector {-# UNPACK #-} !Int
                            {-# UNPACK #-} !Int
                            {-# UNPACK #-} !(ForeignPtr a)
 
                            {-# UNPACK #-} !Int
                            {-# UNPACK #-} !(ForeignPtr a)
 
+type IOVector = MVector RealWorld
+type STVector s = MVector s
+
 instance Storable a => G.MVector MVector a where
 instance Storable a => G.MVector MVector a where
-  {-# INLINE length #-}
-  length (MVector _ n _) = n
+  {-# INLINE basicLength #-}
+  basicLength (MVector _ n _) = n
 
 
-  {-# INLINE unsafeSlice #-}
-  unsafeSlice (MVector i n p) j m
-    = UNSAFE_CHECK(checkSlice) "unsafeSlice" j m n
-    $ MVector (i+j) m p
+  {-# INLINE basicUnsafeSlice #-}
+  basicUnsafeSlice (MVector i n p) j m = MVector (i+j) m p
 
   -- FIXME: implement this properly
 
   -- FIXME: implement this properly
-  {-# INLINE overlaps #-}
-  overlaps (MVector i m p) (MVector j n q)
-    = True
-
-  {-# INLINE unsafeNew #-}
-  unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
-              $ unsafePrimToPrim
-              $ MVector 0 n `fmap` mallocForeignPtrArray n
-
-  {-# INLINE unsafeRead #-}
-  unsafeRead (MVector i n p) j
-    = UNSAFE_CHECK(checkIndex) "unsafeRead" j n
-    $ unsafePrimToPrim
+  {-# INLINE basicOverlaps #-}
+  basicOverlaps (MVector i m p) (MVector j n q) = True
+
+  {-# INLINE basicUnsafeNew #-}
+  basicUnsafeNew n
+    = unsafePrimToPrim
+    $ MVector 0 n `fmap` mallocForeignPtrArray n
+
+  {-# INLINE basicUnsafeRead #-}
+  basicUnsafeRead (MVector i n p) j
+    = unsafePrimToPrim
     $ withForeignPtr p $ \ptr -> peekElemOff ptr (i+j)
 
     $ withForeignPtr p $ \ptr -> peekElemOff ptr (i+j)
 
-  {-# INLINE unsafeWrite #-}
-  unsafeWrite (MVector i n p) j x
-    = UNSAFE_CHECK(checkIndex) "unsafeWrite" j n
-    $ unsafePrimToPrim
-    $ withForeignPtr p $ \ptr -> pokeElemOff ptr (i+j) x 
+  {-# INLINE basicUnsafeWrite #-}
+  basicUnsafeWrite (MVector i n p) j x
+    = unsafePrimToPrim
+    $ withForeignPtr p $ \ptr -> pokeElemOff ptr (i+j) x
+
+
+-- | Yield a part of the mutable vector without copying it. No bounds checks
+-- are performed.
+unsafeSlice :: Storable a => MVector s a -> Int  -- ^ starting index
+                                         -> Int  -- ^ length of the slice
+                                         -> MVector s a
+{-# INLINE unsafeSlice #-}
+unsafeSlice = G.unsafeSlice
+
+
+-- | Create a mutable vector of the given length. The length is not checked.
+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
+{-# INLINE unsafeRead #-}
+unsafeRead = G.unsafeRead
+
+-- | Replace the element at the given position. No bounds checks are performed.
+unsafeWrite :: (PrimMonad m, Storable a)
+                                => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE unsafeWrite #-}
+unsafeWrite = G.unsafeWrite
+
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap. This is not checked.
+unsafeCopy :: (PrimMonad m, Storable a)
+                                => MVector (PrimState m) a   -- ^ target
+                                -> MVector (PrimState m) a   -- ^ source
+                                -> m ()
+{-# INLINE unsafeCopy #-}
+unsafeCopy = G.unsafeCopy
+
+-- | Grow a vector by the given number of elements. The number must be
+-- positive but this is not checked.
+unsafeGrow :: (PrimMonad m, Storable a)
+               => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE unsafeGrow #-}
+unsafeGrow = G.unsafeGrow
+
+-- | Length of the mutable vector.
+length :: Storable a => MVector s a -> Int
+{-# INLINE length #-}
+length = G.length
+
+-- Check whether two vectors overlap.
+overlaps :: Storable a => MVector s a -> MVector s a -> Bool
+{-# INLINE overlaps #-}
+overlaps = G.overlaps
+
+-- | Yield a part of the mutable vector without copying it.
+slice :: Storable a => MVector s a -> Int -> Int -> MVector s a
+{-# INLINE slice #-}
+slice = G.slice
+
+-- | Create a mutable vector of the given length.
+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
+
+-- | Yield the element at the given position.
+read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
+{-# INLINE read #-}
+read = G.read
+
+-- | Replace the element at the given position.
+write :: (PrimMonad m, Storable a)
+                                => MVector (PrimState m) a -> Int -> a -> m ()
+{-# INLINE write #-}
+write = G.write
+
+-- | 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 ()
+{-# INLINE clear #-}
+clear = G.clear
+
+-- | Set all elements of the vector to the given value.
+set :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> a -> m ()
+{-# INLINE set #-}
+set = G.set
+
+-- | Copy a vector. The two vectors must have the same length and may not
+-- overlap.
+copy :: (PrimMonad m, Storable a)
+                => MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
+{-# INLINE copy #-}
+copy = G.copy
 
 
-  {-# INLINE clear #-}
-  clear _ = return ()
+-- | Grow a vector by the given number of elements. The number must be
+-- positive.
+grow :: (PrimMonad m, Storable a)
+              => MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
+{-# INLINE grow #-}
+grow = G.grow
 
 
index 6095078..1415ab4 100644 (file)
@@ -8,8 +8,9 @@ import qualified Data.Vector.Generic.Mutable as M
 
 import qualified Data.Vector.Primitive as P
 
 
 import qualified Data.Vector.Primitive as P
 
+import Control.Monad.Primitive
 import Control.Monad.ST ( runST )
 import Control.Monad.ST ( runST )
-import Control.Monad
+import Control.Monad ( liftM )
 
 import Data.Word ( Word, Word8, Word16, Word32, Word64 )
 import Data.Int  ( Int8, Int16, Int32, Int64 )
 
 import Data.Word ( Word, Word8, Word16, Word32, Word64 )
 import Data.Int  ( Int8, Int16, Int32, Int64 )
@@ -19,10 +20,14 @@ import Data.Int  ( Int8, Int16, Int32, Int64 )
 data family MVector s a
 data family Vector    a
 
 data family MVector s a
 data family Vector    a
 
+type IOVector = MVector RealWorld
+type STVector s = MVector s
+
 type instance G.Mutable Vector = MVector
 
 class (G.Vector Vector a, M.MVector MVector a) => Unbox a
 
 type instance G.Mutable Vector = MVector
 
 class (G.Vector Vector a, M.MVector MVector a) => Unbox a
 
+
 -- ----
 -- Unit
 -- ----
 -- ----
 -- Unit
 -- ----
@@ -33,41 +38,36 @@ newtype instance Vector    () = V_Unit Int
 instance Unbox ()
 
 instance M.MVector MVector () where
 instance Unbox ()
 
 instance M.MVector MVector () where
-  {-# INLINE length #-}
-  {-# INLINE unsafeSlice #-}
-  {-# INLINE overlaps #-}
-  {-# INLINE unsafeNew #-}
-  {-# INLINE unsafeRead #-}
-  {-# INLINE unsafeWrite #-}
-  {-# INLINE clear #-}
-  {-# INLINE set #-}
-  {-# INLINE unsafeCopy #-}
-  {-# INLINE unsafeGrow #-}
+  {-# INLINE basicLength #-}
+  {-# INLINE basicUnsafeSlice #-}
+  {-# INLINE basicOverlaps #-}
+  {-# INLINE basicUnsafeNew #-}
+  {-# INLINE basicUnsafeRead #-}
+  {-# INLINE basicUnsafeWrite #-}
+  {-# INLINE basicClear #-}
+  {-# INLINE basicSet #-}
+  {-# INLINE basicUnsafeCopy #-}
+  {-# INLINE basicUnsafeGrow #-}
 
 
-  length (MV_Unit n) = n
+  basicLength (MV_Unit n) = n
 
 
-  unsafeSlice (MV_Unit n) i m
-    = UNSAFE_CHECK(checkSlice) "unsafeSlice" i m n
-    $ MV_Unit m
+  basicUnsafeSlice (MV_Unit n) i m = MV_Unit m
 
 
-  overlaps _ _ = False
+  basicOverlaps _ _ = False
 
 
-  unsafeNew n = UNSAFE_CHECK(checkLength) "unsafeNew" n
-              $ return (MV_Unit n)
+  basicUnsafeNew n = return (MV_Unit n)
 
 
-  unsafeRead (MV_Unit n) i = UNSAFE_CHECK(checkIndex) "unsafeRead" i n
-                           $ return ()
+  basicUnsafeRead (MV_Unit _) _ = return ()
 
 
-  unsafeWrite (MV_Unit n) i () = UNSAFE_CHECK(checkIndex) "unsafeWrite" i n
-                               $ return ()
+  basicUnsafeWrite (MV_Unit _) _ () = return ()
 
 
-  clear _ = return ()
+  basicClear _ = return ()
 
 
-  set (MV_Unit _) () = return ()
+  basicSet (MV_Unit _) () = return ()
 
 
-  unsafeCopy (MV_Unit _) (MV_Unit _) = return ()
+  basicUnsafeCopy (MV_Unit _) (MV_Unit _) = return ()
 
 
-  unsafeGrow (MV_Unit n) k = return $ MV_Unit (n+k)
+  basicUnsafeGrow (MV_Unit n) m = return $ MV_Unit (n+m)
 
 instance G.Vector Vector () where
   {-# INLINE unsafeFreeze #-}
 
 instance G.Vector Vector () where
   {-# INLINE unsafeFreeze #-}
@@ -89,28 +89,28 @@ instance G.Vector Vector () where
 
 #define primMVector(ty,con)                                             \
 instance M.MVector MVector ty where {                                   \
 
 #define primMVector(ty,con)                                             \
 instance M.MVector MVector ty where {                                   \
-  {-# INLINE length #-}                                                 \
-; {-# INLINE unsafeSlice #-}                                            \
-; {-# INLINE overlaps #-}                                               \
-; {-# INLINE unsafeNew #-}                                              \
-; {-# INLINE unsafeNewWith #-}                                          \
-; {-# INLINE unsafeRead #-}                                             \
-; {-# INLINE unsafeWrite #-}                                            \
-; {-# INLINE clear #-}                                                  \
-; {-# INLINE set #-}                                                    \
-; {-# INLINE unsafeCopy #-}                                             \
-; {-# INLINE unsafeGrow #-}                                             \
-; length (con v) = M.length v                                           \
-; unsafeSlice (con v) i n = con $ M.unsafeSlice v i n                   \
-; overlaps (con v1) (con v2) = M.overlaps v1 v2                         \
-; unsafeNew n = con `liftM` M.unsafeNew n                               \
-; unsafeNewWith n x = con `liftM` M.unsafeNewWith n x                   \
-; unsafeRead (con v) i = M.unsafeRead v i                               \
-; unsafeWrite (con v) i x = M.unsafeWrite v i x                         \
-; clear (con v) = M.clear v                                             \
-; set (con v) x = M.set v x                                             \
-; unsafeCopy (con v1) (con v2) = M.unsafeCopy v1 v2                     \
-; unsafeGrow (con v) n = con `liftM` M.unsafeGrow v n }
+  {-# INLINE basicLength #-}                                            \
+; {-# INLINE basicUnsafeSlice #-}                                       \
+; {-# INLINE basicOverlaps #-}                                          \
+; {-# INLINE basicUnsafeNew #-}                                         \
+; {-# INLINE basicUnsafeNewWith #-}                                     \
+; {-# INLINE basicUnsafeRead #-}                                        \
+; {-# INLINE basicUnsafeWrite #-}                                       \
+; {-# INLINE basicClear #-}                                             \
+; {-# INLINE basicSet #-}                                               \
+; {-# INLINE basicUnsafeCopy #-}                                        \
+; {-# INLINE basicUnsafeGrow #-}                                        \
+; basicLength (con v) = M.basicLength v                                 \
+; basicUnsafeSlice (con v) i n = con $ M.basicUnsafeSlice v i n         \
+; basicOverlaps (con v1) (con v2) = M.basicOverlaps v1 v2               \
+; basicUnsafeNew n = con `liftM` M.basicUnsafeNew n                     \
+; basicUnsafeNewWith n x = con `liftM` M.basicUnsafeNewWith n x         \
+; basicUnsafeRead (con v) i = M.basicUnsafeRead v i                     \
+; basicUnsafeWrite (con v) i x = M.basicUnsafeWrite v i x               \
+; basicClear (con v) = M.basicClear v                                   \
+; basicSet (con v) x = M.basicSet v x                                   \
+; basicUnsafeCopy (con v1) (con v2) = M.basicUnsafeCopy v1 v2           \
+; basicUnsafeGrow (con v) n = con `liftM` M.basicUnsafeGrow v n }
 
 #define primVector(ty,con,mcon)                                         \
 instance G.Vector Vector ty where {                                     \
 
 #define primVector(ty,con,mcon)                                         \
 instance G.Vector Vector ty where {                                     \
@@ -224,28 +224,28 @@ newtype instance Vector    Bool = V_Bool  (P.Vector    Word8)
 instance Unbox Bool
 
 instance M.MVector MVector Bool where
 instance Unbox Bool
 
 instance M.MVector MVector Bool where
-  {-# INLINE length #-}
-  {-# INLINE unsafeSlice #-}
-  {-# INLINE overlaps #-}
-  {-# INLINE unsafeNew #-}
-  {-# INLINE unsafeNewWith #-}
-  {-# INLINE unsafeRead #-}
-  {-# INLINE unsafeWrite #-}
-  {-# INLINE clear #-}
-  {-# INLINE set #-}
-  {-# INLINE unsafeCopy #-}
-  {-# INLINE unsafeGrow #-}
-  length (MV_Bool v) = M.length v
-  unsafeSlice (MV_Bool v) i n = MV_Bool $ M.unsafeSlice v i n
-  overlaps (MV_Bool v1) (MV_Bool v2) = M.overlaps v1 v2
-  unsafeNew n = MV_Bool `liftM` M.unsafeNew n
-  unsafeNewWith n x = MV_Bool `liftM` M.unsafeNewWith n (fromBool x)
-  unsafeRead (MV_Bool v) i = toBool `liftM` M.unsafeRead v i
-  unsafeWrite (MV_Bool v) i x = M.unsafeWrite v i (fromBool x)
-  clear (MV_Bool v) = M.clear v
-  set (MV_Bool v) x = M.set v (fromBool x)
-  unsafeCopy (MV_Bool v1) (MV_Bool v2) = M.unsafeCopy v1 v2
-  unsafeGrow (MV_Bool v) n = MV_Bool `liftM` M.unsafeGrow v n
+  {-# INLINE basicLength #-}
+  {-# INLINE basicUnsafeSlice #-}
+  {-# INLINE basicOverlaps #-}
+  {-# INLINE basicUnsafeNew #-}
+  {-# INLINE basicUnsafeNewWith #-}
+  {-# INLINE basicUnsafeRead #-}
+  {-# INLINE basicUnsafeWrite #-}
+  {-# INLINE basicClear #-}
+  {-# INLINE basicSet #-}
+  {-# INLINE basicUnsafeCopy #-}
+  {-# INLINE basicUnsafeGrow #-}
+  basicLength (MV_Bool v) = M.basicLength v
+  basicUnsafeSlice (MV_Bool v) i n = MV_Bool $ M.basicUnsafeSlice v i n
+  basicOverlaps (MV_Bool v1) (MV_Bool v2) = M.basicOverlaps v1 v2
+  basicUnsafeNew n = MV_Bool `liftM` M.basicUnsafeNew n
+  basicUnsafeNewWith n x = MV_Bool `liftM` M.basicUnsafeNewWith n (fromBool x)
+  basicUnsafeRead (MV_Bool v) i = toBool `liftM` M.basicUnsafeRead v i
+  basicUnsafeWrite (MV_Bool v) i x = M.basicUnsafeWrite v i (fromBool x)
+  basicClear (MV_Bool v) = M.basicClear v
+  basicSet (MV_Bool v) x = M.basicSet v (fromBool x)
+  basicUnsafeCopy (MV_Bool v1) (MV_Bool v2) = M.basicUnsafeCopy v1 v2
+  basicUnsafeGrow (MV_Bool v) n = MV_Bool `liftM` M.basicUnsafeGrow v n
 
 instance G.Vector Vector Bool where
   {-# INLINE unsafeFreeze #-}
 
 instance G.Vector Vector Bool where
   {-# INLINE unsafeFreeze #-}
index 04e7df1..ba191a2 100644 (file)
@@ -44,74 +44,75 @@ generate n =
     patn c n = parens $ con c <+> (var 'n' <> int n)
                               <+> sep [v <> int n | v <- varss]
 
     patn c n = parens $ con c <+> (var 'n' <> int n)
                               <+> sep [v <> int n | v <- varss]
 
-    gen_length c = (pat c, var 'n')
+    qM s = text "M." <> text s
+    qG s = text "G." <> text s
 
 
-    gen_unsafeSlice mod c
+    gen_length c _ = (pat c, var 'n')
+
+    gen_unsafeSlice mod c rec
       = (pat c <+> var 'i' <+> var 'm',
          con c <+> var 'm'
       = (pat c <+> var 'i' <+> var 'm',
          con c <+> var 'm'
-               <+> vcat [parens $ text mod <> char '.' <> text "unsafeSlice"
-                                  <+> vs <+> var 'i' <+> var 'm'
+               <+> vcat [parens
+                         $ text mod <> char '.' <> text rec
+                                    <+> vs <+> var 'i' <+> var 'm'
                                         | vs <- varss])
 
 
                                         | vs <- varss])
 
 
-    gen_overlaps = (patn "MV" 1 <+> patn "MV" 2,
-                    vcat $ r : [text "||" <+> r | r <- rs])
+    gen_overlaps rec = (patn "MV" 1 <+> patn "MV" 2,
+                        vcat $ r : [text "||" <+> r | r <- rs])
       where
       where
-        r : rs = [text "M.overlaps" <+> v <> char '1' <+> v <> char '2'
-                        | v <- varss]
+        r : rs = [qM rec <+> v <> char '1' <+> v <> char '2' | v <- varss]
 
 
-    gen_unsafeNew
+    gen_unsafeNew rec
       = (var 'n',
       = (var 'n',
-         mk_do [v <+> text "<- M.unsafeNew" <+> var 'n' | v <- varss]
+         mk_do [v <+> text "<-" <+> qM rec <+> var 'n' | v <- varss]
                $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
                $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
-    gen_unsafeNewWith
+    gen_unsafeNewWith rec
       = (var 'n' <+> tuple id,
       = (var 'n' <+> tuple id,
-         mk_do [vs <+> text "<- M.unsafeNewWith" <+> var 'n' <+> v
+         mk_do [vs <+> text "<-" <+> qM rec <+> var 'n' <+> v
                         | v  <- vars | vs <- varss]
                $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
                         | v  <- vars | vs <- varss]
                $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
-    gen_unsafeRead
+    gen_unsafeRead rec
       = (pat "MV" <+> var 'i',
       = (pat "MV" <+> var 'i',
-         mk_do [v <+> text "<- M.unsafeRead" <+> vs <+> var 'i' | v  <- vars
-                                                                | vs <- varss]
+         mk_do [v <+> text "<-" <+> qM rec <+> vs <+> var 'i' | v  <- vars
+                                                              | vs <- varss]
                $ text "return" <+> tuple id)
 
                $ text "return" <+> tuple id)
 
-    gen_unsafeWrite
+    gen_unsafeWrite rec
       = (pat "MV" <+> var 'i' <+> tuple id,
       = (pat "MV" <+> var 'i' <+> tuple id,
-         mk_do [text "M.unsafeWrite" <+> vs <+> var 'i' <+> v | v  <- vars
-                                                               | vs <- varss]
+         mk_do [qM rec <+> vs <+> var 'i' <+> v | v  <- vars | vs <- varss]
                empty)
 
                empty)
 
-    gen_clear
-      = (pat "MV", mk_do [text "M.clear" <+> vs | vs <- varss] empty)
+    gen_clear rec
+      = (pat "MV", mk_do [qM rec <+> vs | vs <- varss] empty)
 
 
-    gen_set
+    gen_set rec
       = (pat "MV" <+> tuple id,
       = (pat "MV" <+> tuple id,
-         mk_do [text "M.set" <+> vs <+> v | vs <- varss | v <- vars] empty)
+         mk_do [qM rec <+> vs <+> v | vs <- varss | v <- vars] empty)
 
 
-    gen_unsafeCopy
+    gen_unsafeCopy rec
       = (patn "MV" 1 <+> patn "MV" 2,
       = (patn "MV" 1 <+> patn "MV" 2,
-         mk_do [text "M.unsafeCopy" <+> vs <> char '1' <+> vs <> char '2'
-                        | vs <- varss] empty)
+         mk_do [qM rec <+> vs <> char '1' <+> vs <> char '2' | vs <- varss]
+               empty)
 
 
-    gen_unsafeGrow
+    gen_unsafeGrow rec
       = (pat "MV" <+> var 'm',
       = (pat "MV" <+> var 'm',
-         mk_do [text "M.unsafeGrow" <+> vs <+> var 'm' | vs <- varss]
+         mk_do [qM rec <+> vs <+> var 'm' | vs <- varss]
                $ text "return $" <+> con "MV"
                                  <+> parens (var 'm' <> char '+' <> var 'n')
                                  <+> sep varss)
 
                $ text "return $" <+> con "MV"
                                  <+> parens (var 'm' <> char '+' <> var 'n')
                                  <+> sep varss)
 
-    gen_unsafeFreeze
+    gen_unsafeFreeze rec
       = (pat "MV",
       = (pat "MV",
-         mk_do [vs <> char '\'' <+> text "<- G.unsafeFreeze" <+> vs
-                        | vs <- varss]
+         mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss]
                $ text "return $" <+> con "V" <+> var 'n'
                                  <+> sep [vs <> char '\'' | vs <- varss])
 
                $ text "return $" <+> con "V" <+> var 'n'
                                  <+> sep [vs <> char '\'' | vs <- varss])
 
-    gen_basicUnsafeIndexM
+    gen_basicUnsafeIndexM rec
       = (pat "V" <+> var 'i',
       = (pat "V" <+> var 'i',
-         mk_do [v <+> text "<- G.basicUnsafeIndexM" <+> vs <+> var 'i'
+         mk_do [v <+> text "<-" <+> qG rec <+> vs <+> var 'i'
                         | vs <- varss | v <- vars]
                $ text "return" <+> tuple id)
 
                         | vs <- varss | v <- vars]
                $ text "return" <+> tuple id)
 
@@ -122,23 +123,24 @@ generate n =
                           2
                           $ vcat $ cmds ++ [ret]
 
                           2
                           $ vcat $ cmds ++ [ret]
 
-    method (s, (p,e)) = text "{-# INLINE" <+> text s <+> text " #-}"
-                     $$ hang (text s <+> p)
-                             4
-                             (char '=' <+> e)
+    method (s, f) = case f s of
+                      (p,e) ->  text "{-# INLINE" <+> text s <+> text " #-}"
+                                $$ hang (text s <+> p)
+                                   4
+                                   (char '=' <+> e)
                              
 
                              
 
-    methods_MVector = [("length",            gen_length "MV")
-                      ,("unsafeSlice",       gen_unsafeSlice "M" "MV")
-                      ,("overlaps",          gen_overlaps)
-                      ,("unsafeNew",         gen_unsafeNew)
-                      ,("unsafeNewWith",     gen_unsafeNewWith)
-                      ,("unsafeRead",        gen_unsafeRead)
-                      ,("unsafeWrite",       gen_unsafeWrite)
-                      ,("clear",             gen_clear)
-                      ,("set",               gen_set)
-                      ,("unsafeCopy",        gen_unsafeCopy)
-                      ,("unsafeGrow",        gen_unsafeGrow)]
+    methods_MVector = [("basicLength",            gen_length "MV")
+                      ,("basicUnsafeSlice",       gen_unsafeSlice "M" "MV")
+                      ,("basicOverlaps",          gen_overlaps)
+                      ,("basicUnsafeNew",         gen_unsafeNew)
+                      ,("basicUnsafeNewWith",     gen_unsafeNewWith)
+                      ,("basicUnsafeRead",        gen_unsafeRead)
+                      ,("basicUnsafeWrite",       gen_unsafeWrite)
+                      ,("basicClear",             gen_clear)
+                      ,("basicSet",               gen_set)
+                      ,("basicUnsafeCopy",        gen_unsafeCopy)
+                      ,("basicUnsafeGrow",        gen_unsafeGrow)]
 
     methods_Vector  = [("unsafeFreeze",      gen_unsafeFreeze)
                       ,("basicLength",       gen_length "V")
 
     methods_Vector  = [("unsafeFreeze",      gen_unsafeFreeze)
                       ,("basicLength",       gen_length "V")
index 48917ec..f3e5204 100644 (file)
@@ -6,59 +6,59 @@ data instance Vector (a, b)
                               (Vector b)
 instance (Unbox a, Unbox b) => Unbox (a, b)
 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
                               (Vector b)
 instance (Unbox a, Unbox b) => Unbox (a, b)
 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
-  {-# INLINE length  #-}
-  length (MV_2 n_ as bs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_2 n_ as bs) i_ m_
-      = MV_2 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_2 n_ as bs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_2 n_ as bs) i_ m_
+      = MV_2 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
           return $ MV_2 n_ as bs
           return $ MV_2 n_ as bs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b)
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b)
       = do
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
           return $ MV_2 n_ as bs
           return $ MV_2 n_ as bs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_2 n_ as bs) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_2 n_ as bs) i_
       = do
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
           return (a, b)
           return (a, b)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_2 n_ as bs) i_ (a, b)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-  {-# INLINE clear  #-}
-  clear (MV_2 n_ as bs)
-      = do
-          M.clear as
-          M.clear bs
-  {-# INLINE set  #-}
-  set (MV_2 n_ as bs) (a, b)
-      = do
-          M.set as a
-          M.set bs b
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_2 n_ as bs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_2 n_ as bs) i_ (a, b)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+  {-# INLINE basicClear  #-}
+  basicClear (MV_2 n_ as bs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_2 n_ as bs) (a, b)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_2 n_ as bs) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
           return $ MV_2 (m_+n_) as bs
 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
   {-# INLINE unsafeFreeze  #-}
           return $ MV_2 (m_+n_) as bs
 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
   {-# INLINE unsafeFreeze  #-}
@@ -71,8 +71,8 @@ instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
   basicLength (V_2 n_ as bs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_2 n_ as bs) i_ m_
   basicLength (V_2 n_ as bs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_2 n_ as bs) i_ m_
-      = V_2 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
+      = V_2 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_2 n_ as bs) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_2 n_ as bs) i_
       = do
@@ -91,69 +91,69 @@ instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
 instance (Unbox a,
           Unbox b,
           Unbox c) => M.MVector MVector (a, b, c) where
 instance (Unbox a,
           Unbox b,
           Unbox c) => M.MVector MVector (a, b, c) where
-  {-# INLINE length  #-}
-  length (MV_3 n_ as bs cs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_3 n_ as bs cs) i_ m_
-      = MV_3 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_3 n_ as bs cs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_3 n_ as bs cs) i_ m_
+      = MV_3 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
           return $ MV_3 n_ as bs cs
           return $ MV_3 n_ as bs cs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c)
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c)
       = do
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
           return $ MV_3 n_ as bs cs
           return $ MV_3 n_ as bs cs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_3 n_ as bs cs) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_3 n_ as bs cs) i_
       = do
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
           return (a, b, c)
           return (a, b, c)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-  {-# INLINE clear  #-}
-  clear (MV_3 n_ as bs cs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-  {-# INLINE set  #-}
-  set (MV_3 n_ as bs cs) (a, b, c)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_3 n_ as bs cs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+  {-# INLINE basicClear  #-}
+  basicClear (MV_3 n_ as bs cs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_3 n_ as bs cs) (a, b, c)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_3 n_ as bs cs) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
           return $ MV_3 (m_+n_) as bs cs
 instance (Unbox a,
           Unbox b,
           return $ MV_3 (m_+n_) as bs cs
 instance (Unbox a,
           Unbox b,
@@ -169,9 +169,9 @@ instance (Unbox a,
   basicLength (V_3 n_ as bs cs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
   basicLength (V_3 n_ as bs cs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
-      = V_3 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
+      = V_3 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_3 n_ as bs cs) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_3 n_ as bs cs) i_
       = do
@@ -194,79 +194,82 @@ instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d) => M.MVector MVector (a, b, c, d) where
           Unbox b,
           Unbox c,
           Unbox d) => M.MVector MVector (a, b, c, d) where
-  {-# INLINE length  #-}
-  length (MV_4 n_ as bs cs ds) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_4 n_ as bs cs ds) i_ m_
-      = MV_4 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_4 n_ as bs cs ds) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_4 n_ as bs cs ds) i_ m_
+      = MV_4 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
           return $ MV_4 n_ as bs cs ds
           return $ MV_4 n_ as bs cs ds
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d)
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d)
       = do
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
           return $ MV_4 n_ as bs cs ds
           return $ MV_4 n_ as bs cs ds
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_4 n_ as bs cs ds) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_4 n_ as bs cs ds) i_
       = do
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
           return (a, b, c, d)
           return (a, b, c, d)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-  {-# INLINE clear  #-}
-  clear (MV_4 n_ as bs cs ds)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-  {-# INLINE set  #-}
-  set (MV_4 n_ as bs cs ds) (a, b, c, d)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_4 n_ as bs cs ds) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+  {-# INLINE basicClear  #-}
+  basicClear (MV_4 n_ as bs cs ds)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+  {-# INLINE basicSet  #-}
+  basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
+                                                       bs2
+                                                       cs2
+                                                       ds2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
           return $ MV_4 (m_+n_) as bs cs ds
 instance (Unbox a,
           Unbox b,
           return $ MV_4 (m_+n_) as bs cs ds
 instance (Unbox a,
           Unbox b,
@@ -284,10 +287,10 @@ instance (Unbox a,
   basicLength (V_4 n_ as bs cs ds) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_4 n_ as bs cs ds) i_ m_
   basicLength (V_4 n_ as bs cs ds) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_4 n_ as bs cs ds) i_ m_
-      = V_4 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
+      = V_4 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
       = do
@@ -318,97 +321,97 @@ instance (Unbox a,
           Unbox c,
           Unbox d,
           Unbox e) => M.MVector MVector (a, b, c, d, e) where
           Unbox c,
           Unbox d,
           Unbox e) => M.MVector MVector (a, b, c, d, e) where
-  {-# INLINE length  #-}
-  length (MV_5 n_ as bs cs ds es) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_5 n_ as bs cs ds es) i_ m_
-      = MV_5 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
-                                                    bs2
-                                                    cs2
-                                                    ds2
-                                                    es2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_5 n_ as bs cs ds es) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_5 n_ as bs cs ds es) i_ m_
+      = MV_5 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+                (M.basicUnsafeSlice es i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                         bs2
+                                                         cs2
+                                                         ds2
+                                                         es2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
           return $ MV_5 n_ as bs cs ds es
           return $ MV_5 n_ as bs cs ds es
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
           return $ MV_5 n_ as bs cs ds es
           return $ MV_5 n_ as bs cs ds es
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_5 n_ as bs cs ds es) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
           return (a, b, c, d, e)
           return (a, b, c, d, e)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-  {-# INLINE clear  #-}
-  clear (MV_5 n_ as bs cs ds es)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-  {-# INLINE set  #-}
-  set (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
-                                                      bs2
-                                                      cs2
-                                                      ds2
-                                                      es2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_5 n_ as bs cs ds es) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+  {-# INLINE basicClear  #-}
+  basicClear (MV_5 n_ as bs cs ds es)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+  {-# INLINE basicSet  #-}
+  basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                           bs2
+                                                           cs2
+                                                           ds2
+                                                           es2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
           return $ MV_5 (m_+n_) as bs cs ds es
 instance (Unbox a,
           Unbox b,
           return $ MV_5 (m_+n_) as bs cs ds es
 instance (Unbox a,
           Unbox b,
@@ -428,11 +431,11 @@ instance (Unbox a,
   basicLength (V_5 n_ as bs cs ds es) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_5 n_ as bs cs ds es) i_ m_
   basicLength (V_5 n_ as bs cs ds es) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_5 n_ as bs cs ds es) i_ m_
-      = V_5 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
+      = V_5 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
+               (G.basicUnsafeSlice es i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
       = do
@@ -468,109 +471,109 @@ instance (Unbox a,
           Unbox d,
           Unbox e,
           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
           Unbox d,
           Unbox e,
           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
-  {-# INLINE length  #-}
-  length (MV_6 n_ as bs cs ds es fs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
-      = MV_6 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
-                                                        bs2
-                                                        cs2
-                                                        ds2
-                                                        es2
-                                                        fs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_6 n_ as bs cs ds es fs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
+      = MV_6 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+                (M.basicUnsafeSlice es i_ m_)
+                (M.basicUnsafeSlice fs i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                             bs2
+                                                             cs2
+                                                             ds2
+                                                             es2
+                                                             fs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
           return $ MV_6 n_ as bs cs ds es fs
           return $ MV_6 n_ as bs cs ds es fs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
           return $ MV_6 n_ as bs cs ds es fs
           return $ MV_6 n_ as bs cs ds es fs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_6 n_ as bs cs ds es fs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
           return (a, b, c, d, e, f)
           return (a, b, c, d, e, f)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-  {-# INLINE clear  #-}
-  clear (MV_6 n_ as bs cs ds es fs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-  {-# INLINE set  #-}
-  set (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
-                                                          bs2
-                                                          cs2
-                                                          ds2
-                                                          es2
-                                                          fs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_6 n_ as bs cs ds es fs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+  {-# INLINE basicClear  #-}
+  basicClear (MV_6 n_ as bs cs ds es fs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                               bs2
+                                                               cs2
+                                                               ds2
+                                                               es2
+                                                               fs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
           return $ MV_6 (m_+n_) as bs cs ds es fs
 instance (Unbox a,
           Unbox b,
           return $ MV_6 (m_+n_) as bs cs ds es fs
 instance (Unbox a,
           Unbox b,
@@ -592,12 +595,12 @@ instance (Unbox a,
   basicLength (V_6 n_ as bs cs ds es fs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
   basicLength (V_6 n_ as bs cs ds es fs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
-      = V_6 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
+      = V_6 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
+               (G.basicUnsafeSlice es i_ m_)
+               (G.basicUnsafeSlice fs i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
       = do
@@ -638,121 +641,127 @@ instance (Unbox a,
           Unbox e,
           Unbox f,
           Unbox g) => M.MVector MVector (a, b, c, d, e, f, g) where
           Unbox e,
           Unbox f,
           Unbox g) => M.MVector MVector (a, b, c, d, e, f, g) where
-  {-# INLINE length  #-}
-  length (MV_7 n_ as bs cs ds es fs gs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_7 n_ as bs cs ds es fs gs) i_ m_
-      = MV_7 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
-                                                            bs2
-                                                            cs2
-                                                            ds2
-                                                            es2
-                                                            fs2
-                                                            gs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_7 n_ as bs cs ds es fs gs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_7 n_ as bs cs ds es fs gs) i_ m_
+      = MV_7 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+                (M.basicUnsafeSlice es i_ m_)
+                (M.basicUnsafeSlice fs i_ m_)
+                (M.basicUnsafeSlice gs i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
+                                                                 bs2
+                                                                 cs2
+                                                                 ds2
+                                                                 es2
+                                                                 fs2
+                                                                 gs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
           return $ MV_7 n_ as bs cs ds es fs gs
           return $ MV_7 n_ as bs cs ds es fs gs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
           return $ MV_7 n_ as bs cs ds es fs gs
           return $ MV_7 n_ as bs cs ds es fs gs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_7 n_ as bs cs ds es fs gs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_7 n_ as bs cs ds es fs gs) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
           return (a, b, c, d, e, f, g)
           return (a, b, c, d, e, f, g)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_7 n_ as bs cs ds es fs gs) i_ (a, b, c, d, e, f, g)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-  {-# INLINE clear  #-}
-  clear (MV_7 n_ as bs cs ds es fs gs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-  {-# INLINE set  #-}
-  set (MV_7 n_ as bs cs ds es fs gs) (a, b, c, d, e, f, g)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
-                                                              bs2
-                                                              cs2
-                                                              ds2
-                                                              es2
-                                                              fs2
-                                                              gs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_7 n_ as bs cs ds es fs gs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_7 n_ as
+                            bs
+                            cs
+                            ds
+                            es
+                            fs
+                            gs) i_ (a, b, c, d, e, f, g)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+  {-# INLINE basicClear  #-}
+  basicClear (MV_7 n_ as bs cs ds es fs gs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_7 n_ as bs cs ds es fs gs) (a, b, c, d, e, f, g)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_7 n_1 as1
+                            bs1
+                            cs1
+                            ds1
+                            es1
+                            fs1
+                            gs1) (MV_7 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_7 n_ as bs cs ds es fs gs) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
           return $ MV_7 (m_+n_) as bs cs ds es fs gs
 instance (Unbox a,
           Unbox b,
           return $ MV_7 (m_+n_) as bs cs ds es fs gs
 instance (Unbox a,
           Unbox b,
@@ -776,13 +785,13 @@ instance (Unbox a,
   basicLength (V_7 n_ as bs cs ds es fs gs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_7 n_ as bs cs ds es fs gs) i_ m_
   basicLength (V_7 n_ as bs cs ds es fs gs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_7 n_ as bs cs ds es fs gs) i_ m_
-      = V_7 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
+      = V_7 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
+               (G.basicUnsafeSlice es i_ m_)
+               (G.basicUnsafeSlice fs i_ m_)
+               (G.basicUnsafeSlice gs i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_7 n_ as bs cs ds es fs gs) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_7 n_ as bs cs ds es fs gs) i_
       = do
@@ -828,140 +837,140 @@ instance (Unbox a,
           Unbox f,
           Unbox g,
           Unbox h) => M.MVector MVector (a, b, c, d, e, f, g, h) where
           Unbox f,
           Unbox g,
           Unbox h) => M.MVector MVector (a, b, c, d, e, f, g, h) where
-  {-# INLINE length  #-}
-  length (MV_8 n_ as bs cs ds es fs gs hs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_8 n_ as bs cs ds es fs gs hs) i_ m_
-      = MV_8 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-                (M.unsafeSlice hs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
-                                                                bs2
-                                                                cs2
-                                                                ds2
-                                                                es2
-                                                                fs2
-                                                                gs2
-                                                                hs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_8 n_ as bs cs ds es fs gs hs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_8 n_ as bs cs ds es fs gs hs) i_ m_
+      = MV_8 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+                (M.basicUnsafeSlice es i_ m_)
+                (M.basicUnsafeSlice fs i_ m_)
+                (M.basicUnsafeSlice gs i_ m_)
+                (M.basicUnsafeSlice hs i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_8 n_1 as1
+                          bs1
+                          cs1
+                          ds1
+                          es1
+                          fs1
+                          gs1
+                          hs1) (MV_8 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+        || M.basicOverlaps hs1 hs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
+          hs <- M.basicUnsafeNew n_
           return $ MV_8 n_ as bs cs ds es fs gs hs
           return $ MV_8 n_ as bs cs ds es fs gs hs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
+          hs <- M.basicUnsafeNewWith n_ h
           return $ MV_8 n_ as bs cs ds es fs gs hs
           return $ MV_8 n_ as bs cs ds es fs gs hs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_8 n_ as bs cs ds es fs gs hs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_8 n_ as bs cs ds es fs gs hs) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
+          h <- M.basicUnsafeRead hs i_
           return (a, b, c, d, e, f, g, h)
           return (a, b, c, d, e, f, g, h)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_8 n_ as
-                       bs
-                       cs
-                       ds
-                       es
-                       fs
-                       gs
-                       hs) i_ (a, b, c, d, e, f, g, h)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-  {-# INLINE clear  #-}
-  clear (MV_8 n_ as bs cs ds es fs gs hs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-  {-# INLINE set  #-}
-  set (MV_8 n_ as bs cs ds es fs gs hs) (a, b, c, d, e, f, g, h)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
-                                                                  bs2
-                                                                  cs2
-                                                                  ds2
-                                                                  es2
-                                                                  fs2
-                                                                  gs2
-                                                                  hs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_8 n_ as bs cs ds es fs gs hs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_8 n_ as
+                            bs
+                            cs
+                            ds
+                            es
+                            fs
+                            gs
+                            hs) i_ (a, b, c, d, e, f, g, h)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+          M.basicUnsafeWrite hs i_ h
+  {-# INLINE basicClear  #-}
+  basicClear (MV_8 n_ as bs cs ds es fs gs hs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+          M.basicClear hs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_8 n_ as bs cs ds es fs gs hs) (a, b, c, d, e, f, g, h)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+          M.basicSet hs h
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_8 n_1 as1
+                            bs1
+                            cs1
+                            ds1
+                            es1
+                            fs1
+                            gs1
+                            hs1) (MV_8 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+          M.basicUnsafeCopy hs1 hs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_8 n_ as bs cs ds es fs gs hs) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
+          M.basicUnsafeGrow hs m_
           return $ MV_8 (m_+n_) as bs cs ds es fs gs hs
 instance (Unbox a,
           Unbox b,
           return $ MV_8 (m_+n_) as bs cs ds es fs gs hs
 instance (Unbox a,
           Unbox b,
@@ -987,14 +996,14 @@ instance (Unbox a,
   basicLength (V_8 n_ as bs cs ds es fs gs hs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_8 n_ as bs cs ds es fs gs hs) i_ m_
   basicLength (V_8 n_ as bs cs ds es fs gs hs) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_8 n_ as bs cs ds es fs gs hs) i_ m_
-      = V_8 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
-               (G.unsafeSlice hs i_ m_)
+      = V_8 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
+               (G.basicUnsafeSlice es i_ m_)
+               (G.basicUnsafeSlice fs i_ m_)
+               (G.basicUnsafeSlice gs i_ m_)
+               (G.basicUnsafeSlice hs i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_8 n_ as bs cs ds es fs gs hs) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_8 n_ as bs cs ds es fs gs hs) i_
       = do
@@ -1045,161 +1054,161 @@ instance (Unbox a,
           Unbox g,
           Unbox h,
           Unbox i) => M.MVector MVector (a, b, c, d, e, f, g, h, i) where
           Unbox g,
           Unbox h,
           Unbox i) => M.MVector MVector (a, b, c, d, e, f, g, h, i) where
-  {-# INLINE length  #-}
-  length (MV_9 n_ as bs cs ds es fs gs hs is) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_9 n_ as bs cs ds es fs gs hs is) i_ m_
-      = MV_9 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-                (M.unsafeSlice hs i_ m_)
-                (M.unsafeSlice is i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_9 n_1 as1
-                     bs1
-                     cs1
-                     ds1
-                     es1
-                     fs1
-                     gs1
-                     hs1
-                     is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_9 n_ as bs cs ds es fs gs hs is) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_9 n_ as bs cs ds es fs gs hs is) i_ m_
+      = MV_9 m_ (M.basicUnsafeSlice as i_ m_)
+                (M.basicUnsafeSlice bs i_ m_)
+                (M.basicUnsafeSlice cs i_ m_)
+                (M.basicUnsafeSlice ds i_ m_)
+                (M.basicUnsafeSlice es i_ m_)
+                (M.basicUnsafeSlice fs i_ m_)
+                (M.basicUnsafeSlice gs i_ m_)
+                (M.basicUnsafeSlice hs i_ m_)
+                (M.basicUnsafeSlice is i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_9 n_1 as1
+                          bs1
+                          cs1
+                          ds1
+                          es1
+                          fs1
+                          gs1
+                          hs1
+                          is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+        || M.basicOverlaps hs1 hs2
+        || M.basicOverlaps is1 is2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
+          hs <- M.basicUnsafeNew n_
+          is <- M.basicUnsafeNew n_
           return $ MV_9 n_ as bs cs ds es fs gs hs is
           return $ MV_9 n_ as bs cs ds es fs gs hs is
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
+          hs <- M.basicUnsafeNewWith n_ h
+          is <- M.basicUnsafeNewWith n_ i
           return $ MV_9 n_ as bs cs ds es fs gs hs is
           return $ MV_9 n_ as bs cs ds es fs gs hs is
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_9 n_ as bs cs ds es fs gs hs is) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_9 n_ as bs cs ds es fs gs hs is) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
+          h <- M.basicUnsafeRead hs i_
+          i <- M.basicUnsafeRead is i_
           return (a, b, c, d, e, f, g, h, i)
           return (a, b, c, d, e, f, g, h, i)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_9 n_ as
-                       bs
-                       cs
-                       ds
-                       es
-                       fs
-                       gs
-                       hs
-                       is) i_ (a, b, c, d, e, f, g, h, i)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-  {-# INLINE clear  #-}
-  clear (MV_9 n_ as bs cs ds es fs gs hs is)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-  {-# INLINE set  #-}
-  set (MV_9 n_ as
-               bs
-               cs
-               ds
-               es
-               fs
-               gs
-               hs
-               is) (a, b, c, d, e, f, g, h, i)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_9 n_1 as1
-                       bs1
-                       cs1
-                       ds1
-                       es1
-                       fs1
-                       gs1
-                       hs1
-                       is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_9 n_ as bs cs ds es fs gs hs is) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_9 n_ as
+                            bs
+                            cs
+                            ds
+                            es
+                            fs
+                            gs
+                            hs
+                            is) i_ (a, b, c, d, e, f, g, h, i)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+          M.basicUnsafeWrite hs i_ h
+          M.basicUnsafeWrite is i_ i
+  {-# INLINE basicClear  #-}
+  basicClear (MV_9 n_ as bs cs ds es fs gs hs is)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+          M.basicClear hs
+          M.basicClear is
+  {-# INLINE basicSet  #-}
+  basicSet (MV_9 n_ as
+                    bs
+                    cs
+                    ds
+                    es
+                    fs
+                    gs
+                    hs
+                    is) (a, b, c, d, e, f, g, h, i)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+          M.basicSet hs h
+          M.basicSet is i
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_9 n_1 as1
+                            bs1
+                            cs1
+                            ds1
+                            es1
+                            fs1
+                            gs1
+                            hs1
+                            is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+          M.basicUnsafeCopy hs1 hs2
+          M.basicUnsafeCopy is1 is2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_9 n_ as bs cs ds es fs gs hs is) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
+          M.basicUnsafeGrow hs m_
+          M.basicUnsafeGrow is m_
           return $ MV_9 (m_+n_) as bs cs ds es fs gs hs is
 instance (Unbox a,
           Unbox b,
           return $ MV_9 (m_+n_) as bs cs ds es fs gs hs is
 instance (Unbox a,
           Unbox b,
@@ -1227,15 +1236,15 @@ instance (Unbox a,
   basicLength (V_9 n_ as bs cs ds es fs gs hs is) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_9 n_ as bs cs ds es fs gs hs is) i_ m_
   basicLength (V_9 n_ as bs cs ds es fs gs hs is) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_9 n_ as bs cs ds es fs gs hs is) i_ m_
-      = V_9 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
-               (G.unsafeSlice hs i_ m_)
-               (G.unsafeSlice is i_ m_)
+      = V_9 m_ (G.basicUnsafeSlice as i_ m_)
+               (G.basicUnsafeSlice bs i_ m_)
+               (G.basicUnsafeSlice cs i_ m_)
+               (G.basicUnsafeSlice ds i_ m_)
+               (G.basicUnsafeSlice es i_ m_)
+               (G.basicUnsafeSlice fs i_ m_)
+               (G.basicUnsafeSlice gs i_ m_)
+               (G.basicUnsafeSlice hs i_ m_)
+               (G.basicUnsafeSlice is i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_9 n_ as bs cs ds es fs gs hs is) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_9 n_ as bs cs ds es fs gs hs is) i_
       = do
@@ -1291,175 +1300,175 @@ instance (Unbox a,
           Unbox h,
           Unbox i,
           Unbox j) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j) where
           Unbox h,
           Unbox i,
           Unbox j) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j) where
-  {-# INLINE length  #-}
-  length (MV_10 n_ as bs cs ds es fs gs hs is js) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_10 n_ as bs cs ds es fs gs hs is js) i_ m_
-      = MV_10 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_10 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_10 n_ as bs cs ds es fs gs hs is js) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_10 n_ as bs cs ds es fs gs hs is js) i_ m_
+      = MV_10 m_ (M.basicUnsafeSlice as i_ m_)
+                 (M.basicUnsafeSlice bs i_ m_)
+                 (M.basicUnsafeSlice cs i_ m_)
+                 (M.basicUnsafeSlice ds i_ m_)
+                 (M.basicUnsafeSlice es i_ m_)
+                 (M.basicUnsafeSlice fs i_ m_)
+                 (M.basicUnsafeSlice gs i_ m_)
+                 (M.basicUnsafeSlice hs i_ m_)
+                 (M.basicUnsafeSlice is i_ m_)
+                 (M.basicUnsafeSlice js i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_10 n_1 as1
+                           bs1
+                           cs1
+                           ds1
+                           es1
+                           fs1
+                           gs1
+                           hs1
+                           is1
+                           js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+        || M.basicOverlaps hs1 hs2
+        || M.basicOverlaps is1 is2
+        || M.basicOverlaps js1 js2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
+          hs <- M.basicUnsafeNew n_
+          is <- M.basicUnsafeNew n_
+          js <- M.basicUnsafeNew n_
           return $ MV_10 n_ as bs cs ds es fs gs hs is js
           return $ MV_10 n_ as bs cs ds es fs gs hs is js
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
+          hs <- M.basicUnsafeNewWith n_ h
+          is <- M.basicUnsafeNewWith n_ i
+          js <- M.basicUnsafeNewWith n_ j
           return $ MV_10 n_ as bs cs ds es fs gs hs is js
           return $ MV_10 n_ as bs cs ds es fs gs hs is js
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_10 n_ as bs cs ds es fs gs hs is js) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_10 n_ as bs cs ds es fs gs hs is js) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
+          h <- M.basicUnsafeRead hs i_
+          i <- M.basicUnsafeRead is i_
+          j <- M.basicUnsafeRead js i_
           return (a, b, c, d, e, f, g, h, i, j)
           return (a, b, c, d, e, f, g, h, i, j)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_10 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js) i_ (a, b, c, d, e, f, g, h, i, j)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-  {-# INLINE clear  #-}
-  clear (MV_10 n_ as bs cs ds es fs gs hs is js)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-  {-# INLINE set  #-}
-  set (MV_10 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js) (a, b, c, d, e, f, g, h, i, j)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_10 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_10 n_ as bs cs ds es fs gs hs is js) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_10 n_ as
+                             bs
+                             cs
+                             ds
+                             es
+                             fs
+                             gs
+                             hs
+                             is
+                             js) i_ (a, b, c, d, e, f, g, h, i, j)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+          M.basicUnsafeWrite hs i_ h
+          M.basicUnsafeWrite is i_ i
+          M.basicUnsafeWrite js i_ j
+  {-# INLINE basicClear  #-}
+  basicClear (MV_10 n_ as bs cs ds es fs gs hs is js)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+          M.basicClear hs
+          M.basicClear is
+          M.basicClear js
+  {-# INLINE basicSet  #-}
+  basicSet (MV_10 n_ as
+                     bs
+                     cs
+                     ds
+                     es
+                     fs
+                     gs
+                     hs
+                     is
+                     js) (a, b, c, d, e, f, g, h, i, j)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+          M.basicSet hs h
+          M.basicSet is i
+          M.basicSet js j
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_10 n_1 as1
+                             bs1
+                             cs1
+                             ds1
+                             es1
+                             fs1
+                             gs1
+                             hs1
+                             is1
+                             js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+          M.basicUnsafeCopy hs1 hs2
+          M.basicUnsafeCopy is1 is2
+          M.basicUnsafeCopy js1 js2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_10 n_ as bs cs ds es fs gs hs is js) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
+          M.basicUnsafeGrow hs m_
+          M.basicUnsafeGrow is m_
+          M.basicUnsafeGrow js m_
           return $ MV_10 (m_+n_) as bs cs ds es fs gs hs is js
 instance (Unbox a,
           Unbox b,
           return $ MV_10 (m_+n_) as bs cs ds es fs gs hs is js
 instance (Unbox a,
           Unbox b,
@@ -1489,16 +1498,16 @@ instance (Unbox a,
   basicLength (V_10 n_ as bs cs ds es fs gs hs is js) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_10 n_ as bs cs ds es fs gs hs is js) i_ m_
   basicLength (V_10 n_ as bs cs ds es fs gs hs is js) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_10 n_ as bs cs ds es fs gs hs is js) i_ m_
-      = V_10 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
+      = V_10 m_ (G.basicUnsafeSlice as i_ m_)
+                (G.basicUnsafeSlice bs i_ m_)
+                (G.basicUnsafeSlice cs i_ m_)
+                (G.basicUnsafeSlice ds i_ m_)
+                (G.basicUnsafeSlice es i_ m_)
+                (G.basicUnsafeSlice fs i_ m_)
+                (G.basicUnsafeSlice gs i_ m_)
+                (G.basicUnsafeSlice hs i_ m_)
+                (G.basicUnsafeSlice is i_ m_)
+                (G.basicUnsafeSlice js i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_10 n_ as bs cs ds es fs gs hs is js) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_10 n_ as bs cs ds es fs gs hs is js) i_
       = do
@@ -1559,189 +1568,189 @@ instance (Unbox a,
           Unbox i,
           Unbox j,
           Unbox k) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k) where
           Unbox i,
           Unbox j,
           Unbox k) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k) where
-  {-# INLINE length  #-}
-  length (MV_11 n_ as bs cs ds es fs gs hs is js ks) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
-      = MV_11 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-                 (M.unsafeSlice ks i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_11 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1
-                      ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-        || M.overlaps ks1 ks2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
-          ks <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_11 n_ as bs cs ds es fs gs hs is js ks) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
+      = MV_11 m_ (M.basicUnsafeSlice as i_ m_)
+                 (M.basicUnsafeSlice bs i_ m_)
+                 (M.basicUnsafeSlice cs i_ m_)
+                 (M.basicUnsafeSlice ds i_ m_)
+                 (M.basicUnsafeSlice es i_ m_)
+                 (M.basicUnsafeSlice fs i_ m_)
+                 (M.basicUnsafeSlice gs i_ m_)
+                 (M.basicUnsafeSlice hs i_ m_)
+                 (M.basicUnsafeSlice is i_ m_)
+                 (M.basicUnsafeSlice js i_ m_)
+                 (M.basicUnsafeSlice ks i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_11 n_1 as1
+                           bs1
+                           cs1
+                           ds1
+                           es1
+                           fs1
+                           gs1
+                           hs1
+                           is1
+                           js1
+                           ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+        || M.basicOverlaps hs1 hs2
+        || M.basicOverlaps is1 is2
+        || M.basicOverlaps js1 js2
+        || M.basicOverlaps ks1 ks2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
+          hs <- M.basicUnsafeNew n_
+          is <- M.basicUnsafeNew n_
+          js <- M.basicUnsafeNew n_
+          ks <- M.basicUnsafeNew n_
           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
-          ks <- M.unsafeNewWith n_ k
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
+          hs <- M.basicUnsafeNewWith n_ h
+          is <- M.basicUnsafeNewWith n_ i
+          js <- M.basicUnsafeNewWith n_ j
+          ks <- M.basicUnsafeNewWith n_ k
           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
           return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
-          k <- M.unsafeRead ks i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
+          h <- M.basicUnsafeRead hs i_
+          i <- M.basicUnsafeRead is i_
+          j <- M.basicUnsafeRead js i_
+          k <- M.basicUnsafeRead ks i_
           return (a, b, c, d, e, f, g, h, i, j, k)
           return (a, b, c, d, e, f, g, h, i, j, k)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_11 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js
-                        ks) i_ (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-          M.unsafeWrite ks i_ k
-  {-# INLINE clear  #-}
-  clear (MV_11 n_ as bs cs ds es fs gs hs is js ks)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-          M.clear ks
-  {-# INLINE set  #-}
-  set (MV_11 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js
-                ks) (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-          M.set ks k
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_11 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1
-                        ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-          M.unsafeCopy ks1 ks2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_11 n_ as bs cs ds es fs gs hs is js ks) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
-          M.unsafeGrow ks m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_11 n_ as
+                             bs
+                             cs
+                             ds
+                             es
+                             fs
+                             gs
+                             hs
+                             is
+                             js
+                             ks) i_ (a, b, c, d, e, f, g, h, i, j, k)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+          M.basicUnsafeWrite hs i_ h
+          M.basicUnsafeWrite is i_ i
+          M.basicUnsafeWrite js i_ j
+          M.basicUnsafeWrite ks i_ k
+  {-# INLINE basicClear  #-}
+  basicClear (MV_11 n_ as bs cs ds es fs gs hs is js ks)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+          M.basicClear hs
+          M.basicClear is
+          M.basicClear js
+          M.basicClear ks
+  {-# INLINE basicSet  #-}
+  basicSet (MV_11 n_ as
+                     bs
+                     cs
+                     ds
+                     es
+                     fs
+                     gs
+                     hs
+                     is
+                     js
+                     ks) (a, b, c, d, e, f, g, h, i, j, k)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+          M.basicSet hs h
+          M.basicSet is i
+          M.basicSet js j
+          M.basicSet ks k
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_11 n_1 as1
+                             bs1
+                             cs1
+                             ds1
+                             es1
+                             fs1
+                             gs1
+                             hs1
+                             is1
+                             js1
+                             ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+          M.basicUnsafeCopy hs1 hs2
+          M.basicUnsafeCopy is1 is2
+          M.basicUnsafeCopy js1 js2
+          M.basicUnsafeCopy ks1 ks2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_11 n_ as bs cs ds es fs gs hs is js ks) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
+          M.basicUnsafeGrow hs m_
+          M.basicUnsafeGrow is m_
+          M.basicUnsafeGrow js m_
+          M.basicUnsafeGrow ks m_
           return $ MV_11 (m_+n_) as bs cs ds es fs gs hs is js ks
 instance (Unbox a,
           Unbox b,
           return $ MV_11 (m_+n_) as bs cs ds es fs gs hs is js ks
 instance (Unbox a,
           Unbox b,
@@ -1773,17 +1782,17 @@ instance (Unbox a,
   basicLength (V_11 n_ as bs cs ds es fs gs hs is js ks) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
   basicLength (V_11 n_ as bs cs ds es fs gs hs is js ks) = n_
   {-# INLINE basicUnsafeSlice  #-}
   basicUnsafeSlice (V_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
-      = V_11 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
-                (G.unsafeSlice ks i_ m_)
+      = V_11 m_ (G.basicUnsafeSlice as i_ m_)
+                (G.basicUnsafeSlice bs i_ m_)
+                (G.basicUnsafeSlice cs i_ m_)
+                (G.basicUnsafeSlice ds i_ m_)
+                (G.basicUnsafeSlice es i_ m_)
+                (G.basicUnsafeSlice fs i_ m_)
+                (G.basicUnsafeSlice gs i_ m_)
+                (G.basicUnsafeSlice hs i_ m_)
+                (G.basicUnsafeSlice is i_ m_)
+                (G.basicUnsafeSlice js i_ m_)
+                (G.basicUnsafeSlice ks i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_11 n_ as bs cs ds es fs gs hs is js ks) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_11 n_ as bs cs ds es fs gs hs is js ks) i_
       = do
@@ -1849,203 +1858,214 @@ instance (Unbox a,
           Unbox j,
           Unbox k,
           Unbox l) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k, l) where
           Unbox j,
           Unbox k,
           Unbox l) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k, l) where
-  {-# INLINE length  #-}
-  length (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_ m_
-      = MV_12 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-                 (M.unsafeSlice ks i_ m_)
-                 (M.unsafeSlice ls i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_12 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1
-                      ks1
-                      ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-        || M.overlaps ks1 ks2
-        || M.overlaps ls1 ls2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
-          ks <- M.unsafeNew n_
-          ls <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice (MV_12 n_ as
+                             bs
+                             cs
+                             ds
+                             es
+                             fs
+                             gs
+                             hs
+                             is
+                             js
+                             ks
+                             ls) i_ m_
+      = MV_12 m_ (M.basicUnsafeSlice as i_ m_)
+                 (M.basicUnsafeSlice bs i_ m_)
+                 (M.basicUnsafeSlice cs i_ m_)
+                 (M.basicUnsafeSlice ds i_ m_)
+                 (M.basicUnsafeSlice es i_ m_)
+                 (M.basicUnsafeSlice fs i_ m_)
+                 (M.basicUnsafeSlice gs i_ m_)
+                 (M.basicUnsafeSlice hs i_ m_)
+                 (M.basicUnsafeSlice is i_ m_)
+                 (M.basicUnsafeSlice js i_ m_)
+                 (M.basicUnsafeSlice ks i_ m_)
+                 (M.basicUnsafeSlice ls i_ m_)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_12 n_1 as1
+                           bs1
+                           cs1
+                           ds1
+                           es1
+                           fs1
+                           gs1
+                           hs1
+                           is1
+                           js1
+                           ks1
+                           ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+        || M.basicOverlaps gs1 gs2
+        || M.basicOverlaps hs1 hs2
+        || M.basicOverlaps is1 is2
+        || M.basicOverlaps js1 js2
+        || M.basicOverlaps ks1 ks2
+        || M.basicOverlaps ls1 ls2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
+          gs <- M.basicUnsafeNew n_
+          hs <- M.basicUnsafeNew n_
+          is <- M.basicUnsafeNew n_
+          js <- M.basicUnsafeNew n_
+          ks <- M.basicUnsafeNew n_
+          ls <- M.basicUnsafeNew n_
           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
-          ks <- M.unsafeNewWith n_ k
-          ls <- M.unsafeNewWith n_ l
+  {-# INLINE basicUnsafeNewWith  #-}
+  basicUnsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k, l)
+      = do
+          as <- M.basicUnsafeNewWith n_ a
+          bs <- M.basicUnsafeNewWith n_ b
+          cs <- M.basicUnsafeNewWith n_ c
+          ds <- M.basicUnsafeNewWith n_ d
+          es <- M.basicUnsafeNewWith n_ e
+          fs <- M.basicUnsafeNewWith n_ f
+          gs <- M.basicUnsafeNewWith n_ g
+          hs <- M.basicUnsafeNewWith n_ h
+          is <- M.basicUnsafeNewWith n_ i
+          js <- M.basicUnsafeNewWith n_ j
+          ks <- M.basicUnsafeNewWith n_ k
+          ls <- M.basicUnsafeNewWith n_ l
           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
           return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
-          k <- M.unsafeRead ks i_
-          l <- M.unsafeRead ls i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
+          g <- M.basicUnsafeRead gs i_
+          h <- M.basicUnsafeRead hs i_
+          i <- M.basicUnsafeRead is i_
+          j <- M.basicUnsafeRead js i_
+          k <- M.basicUnsafeRead ks i_
+          l <- M.basicUnsafeRead ls i_
           return (a, b, c, d, e, f, g, h, i, j, k, l)
           return (a, b, c, d, e, f, g, h, i, j, k, l)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_12 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js
-                        ks
-                        ls) i_ (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-          M.unsafeWrite ks i_ k
-          M.unsafeWrite ls i_ l
-  {-# INLINE clear  #-}
-  clear (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-          M.clear ks
-          M.clear ls
-  {-# INLINE set  #-}
-  set (MV_12 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js
-                ks
-                ls) (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-          M.set ks k
-          M.set ls l
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_12 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1
-                        ks1
-                        ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-          M.unsafeCopy ks1 ks2
-          M.unsafeCopy ls1 ls2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
-          M.unsafeGrow ks m_
-          M.unsafeGrow ls m_
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_12 n_ as
+                             bs
+                             cs
+                             ds
+                             es
+                             fs
+                             gs
+                             hs
+                             is
+                             js
+                             ks
+                             ls) i_ (a, b, c, d, e, f, g, h, i, j, k, l)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+          M.basicUnsafeWrite gs i_ g
+          M.basicUnsafeWrite hs i_ h
+          M.basicUnsafeWrite is i_ i
+          M.basicUnsafeWrite js i_ j
+          M.basicUnsafeWrite ks i_ k
+          M.basicUnsafeWrite ls i_ l
+  {-# INLINE basicClear  #-}
+  basicClear (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+          M.basicClear gs
+          M.basicClear hs
+          M.basicClear is
+          M.basicClear js
+          M.basicClear ks
+          M.basicClear ls
+  {-# INLINE basicSet  #-}
+  basicSet (MV_12 n_ as
+                     bs
+                     cs
+                     ds
+                     es
+                     fs
+                     gs
+                     hs
+                     is
+                     js
+                     ks
+                     ls) (a, b, c, d, e, f, g, h, i, j, k, l)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+          M.basicSet gs g
+          M.basicSet hs h
+          M.basicSet is i
+          M.basicSet js j
+          M.basicSet ks k
+          M.basicSet ls l
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_12 n_1 as1
+                             bs1
+                             cs1
+                             ds1
+                             es1
+                             fs1
+                             gs1
+                             hs1
+                             is1
+                             js1
+                             ks1
+                             ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+          M.basicUnsafeCopy gs1 gs2
+          M.basicUnsafeCopy hs1 hs2
+          M.basicUnsafeCopy is1 is2
+          M.basicUnsafeCopy js1 js2
+          M.basicUnsafeCopy ks1 ks2
+          M.basicUnsafeCopy ls1 ls2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) m_
+      = do
+          M.basicUnsafeGrow as m_
+          M.basicUnsafeGrow bs m_
+          M.basicUnsafeGrow cs m_
+          M.basicUnsafeGrow ds m_
+          M.basicUnsafeGrow es m_
+          M.basicUnsafeGrow fs m_
+          M.basicUnsafeGrow gs m_
+          M.basicUnsafeGrow hs m_
+          M.basicUnsafeGrow is m_
+          M.basicUnsafeGrow js m_
+          M.basicUnsafeGrow ks m_
+          M.basicUnsafeGrow ls m_
           return $ MV_12 (m_+n_) as bs cs ds es fs gs hs is js ks ls
 instance (Unbox a,
           Unbox b,
           return $ MV_12 (m_+n_) as bs cs ds es fs gs hs is js ks ls
 instance (Unbox a,
           Unbox b,
@@ -2090,18 +2110,18 @@ instance (Unbox a,
                             js
                             ks
                             ls) i_ m_
                             js
                             ks
                             ls) i_ m_
-      = V_12 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
-                (G.unsafeSlice ks i_ m_)
-                (G.unsafeSlice ls i_ m_)
+      = V_12 m_ (G.basicUnsafeSlice as i_ m_)
+                (G.basicUnsafeSlice bs i_ m_)
+                (G.basicUnsafeSlice cs i_ m_)
+                (G.basicUnsafeSlice ds i_ m_)
+                (G.basicUnsafeSlice es i_ m_)
+                (G.basicUnsafeSlice fs i_ m_)
+                (G.basicUnsafeSlice gs i_ m_)
+                (G.basicUnsafeSlice hs i_ m_)
+                (G.basicUnsafeSlice is i_ m_)
+                (G.basicUnsafeSlice js i_ m_)
+                (G.basicUnsafeSlice ks i_ m_)
+                (G.basicUnsafeSlice ls i_ m_)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
       = do
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
       = do