Switch the order of argument to slice and unsafeSlice
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 9 Dec 2009 13:59:47 +0000 (13:59 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Wed, 9 Dec 2009 13:59:47 +0000 (13:59 +0000)
16 files changed:
Data/Vector.hs
Data/Vector/Fusion/Stream.hs
Data/Vector/Fusion/Stream/Monadic.hs
Data/Vector/Generic.hs
Data/Vector/Generic/Mutable.hs
Data/Vector/Generic/New.hs
Data/Vector/Mutable.hs
Data/Vector/Primitive.hs
Data/Vector/Primitive/Mutable.hs
Data/Vector/Storable.hs
Data/Vector/Storable/Mutable.hs
Data/Vector/Unboxed.hs
Data/Vector/Unboxed/Base.hs
Data/Vector/Unboxed/Mutable.hs
internal/GenUnboxTuple.hs
internal/unbox-tuple-instances

index 6b54a3c..4e6a96f 100644 (file)
@@ -119,7 +119,7 @@ instance G.Vector Vector a where
   basicLength (Vector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (Vector i _ arr) j n = Vector (i+j) n arr
+  basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
 
   {-# INLINE basicUnsafeIndexM #-}
   basicUnsafeIndexM (Vector i _ arr) j = indexArrayM arr (i+j)
@@ -255,17 +255,19 @@ unsafeLastM = G.unsafeLastM
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'basicUnsafeSlice'.
-slice :: Vector a -> Int   -- ^ starting index
-                  -> Int   -- ^ length
-                  -> Vector a
+slice :: Int   -- ^ starting index
+      -> Int   -- ^ length
+      -> Vector a
+      -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
 -- | Unsafely yield a part of the vector without copying it and without
 -- performing bounds checks.
-unsafeSlice :: Vector a -> Int   -- ^ starting index
-                        -> Int   -- ^ length
-                        -> Vector a
+unsafeSlice :: Int   -- ^ starting index
+            -> Int   -- ^ length
+            -> Vector a
+            -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
index 040cc67..ae9a225 100644 (file)
@@ -32,7 +32,7 @@ module Data.Vector.Fusion.Stream (
   head, last, (!!),
 
   -- * Substreams
-  extract, init, tail, take, drop,
+  slice, init, tail, take, drop,
 
   -- * Mapping
   map, concatMap, unbox,
@@ -204,11 +204,12 @@ s !! i = unId (s M.!! i)
 -- ----------
 
 -- | Extract a substream of the given length starting at the given position.
-extract :: Stream a -> Int   -- ^ starting index
-                    -> Int   -- ^ length
-                    -> Stream a
-{-# INLINE extract #-}
-extract = M.extract
+slice :: Int   -- ^ starting index
+      -> Int   -- ^ length
+      -> Stream a
+      -> Stream a
+{-# INLINE slice #-}
+slice = M.slice
 
 -- | All but the last element
 init :: Stream a -> Stream a
index d8ec6d8..9c3c513 100644 (file)
@@ -28,7 +28,7 @@ module Data.Vector.Fusion.Stream.Monadic (
   head, last, (!!),
 
   -- * Substreams
-  extract, init, tail, take, drop,
+  slice, init, tail, take, drop,
 
   -- * Mapping
   map, mapM, mapM_, trans, unbox, concatMap,
@@ -268,11 +268,12 @@ Stream step s _ !! i | i < 0     = BOUNDS_ERROR(error) "!!" "negative index"
 -- ----------
 
 -- | Extract a substream of the given length starting at the given position.
-extract :: Monad m => Stream m a -> Int   -- ^ starting index
-                                 -> Int   -- ^ length
-                                 -> Stream m a
-{-# INLINE extract #-}
-extract s i n = take n (drop i s)
+slice :: Monad m => Int   -- ^ starting index
+                 -> Int   -- ^ length
+                 -> Stream m a
+                 -> Stream m a
+{-# INLINE slice #-}
+slice i n s = take n (drop i s)
 
 -- | All but the last element
 init :: Monad m => Stream m a -> Stream m a
index 635a381..6c1b112 100644 (file)
@@ -133,7 +133,7 @@ class MVector (Mutable v) a => Vector v a where
   basicLength      :: v a -> Int
 
   -- | Yield a part of the vector without copying it. No range checks!
-  basicUnsafeSlice  :: v a -> Int -> Int -> v a
+  basicUnsafeSlice  :: Int -> Int -> v a -> v a
 
   -- | Yield the element at the given position in a monad. The monad allows us
   -- to be strict in the vector if we want. Suppose we had
@@ -407,52 +407,54 @@ unsafeLastM v = unsafeIndexM v (length v - 1)
 -- FIXME: slicing doesn't work with the inplace stuff at the moment
 
 -- | Yield a part of the vector without copying it.
-slice :: Vector v a => v a -> Int   -- ^ starting index
-                           -> Int   -- ^ length
-                           -> v a
+slice :: Vector v a => Int   -- ^ starting index
+                    -> Int   -- ^ length
+                    -> v a
+                    -> v a
 {-# INLINE_STREAM slice #-}
-slice v i n = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
-            $ basicUnsafeSlice v i n
+slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
+            $ basicUnsafeSlice i n v
 
 -- | Unsafely yield a part of the vector without copying it and without
 -- performing bounds checks.
-unsafeSlice :: Vector v a => v a -> Int   -- ^ starting index
-                                 -> Int   -- ^ length
-                                 -> v a
+unsafeSlice :: Vector v a => Int   -- ^ starting index
+                          -> Int   -- ^ length
+                          -> v a
+                          -> v a
 {-# INLINE_STREAM unsafeSlice #-}
-unsafeSlice v i n = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
-                  $ basicUnsafeSlice v i n
+unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
+                  $ basicUnsafeSlice i n v
 
 -- | Yield all but the last element without copying.
 init :: Vector v a => v a -> v a
 {-# INLINE_STREAM init #-}
-init v = slice v 0 (length v - 1)
+init v = slice 0 (length v - 1) v
 
 -- | All but the first element (without copying).
 tail :: Vector v a => v a -> v a
 {-# INLINE_STREAM tail #-}
-tail v = slice v 1 (length v - 1)
+tail v = slice 1 (length v - 1) v
 
 -- | Yield the first @n@ elements without copying.
 take :: Vector v a => Int -> v a -> v a
 {-# INLINE_STREAM take #-}
-take n v = slice v 0 (min n' (length v))
+take n v = slice 0 (min n' (length v)) v
   where n' = max n 0
 
 -- | Yield all but the first @n@ elements without copying.
 drop :: Vector v a => Int -> v a -> v a
 {-# INLINE_STREAM drop #-}
-drop n v = slice v (min n' len) (max 0 (len - n'))
+drop n v = slice (min n' len) (max 0 (len - n')) v
   where n' = max n 0
         len = length v
 
 {-# RULES
 
-"slice/new [Vector]" forall v p i n.
-  slice (new' v p) i n = new' v (New.slice p i n)
+"slice/new [Vector]" forall i n v p.
+  slice i n (new' v p) = new' v (New.slice i n p)
 
-"unsafeSlice/new [Vector]" forall v p i n.
-  unsafeSlice (new' v p) i n = new' v (New.unsafeSlice p i n)
+"unsafeSlice/new [Vector]" forall i n v p.
+  unsafeSlice i n (new' v p) = new' v (New.unsafeSlice i n p)
 
 "init/new [Vector]" forall v p.
   init (new' v p) = new' v (New.init p)
@@ -834,7 +836,7 @@ span f = break (not . f)
 break :: Vector v a => (a -> Bool) -> v a -> (v a, v a)
 {-# INLINE break #-}
 break f xs = case findIndex f xs of
-               Just i  -> (unsafeSlice xs 0 i, unsafeSlice xs i (length xs - i))
+               Just i  -> (unsafeSlice 0 i xs, unsafeSlice i (length xs - i) xs)
                Nothing -> (xs, empty)
     
 
index 846e530..2b88796 100644 (file)
@@ -54,9 +54,10 @@ class MVector v a where
 
   -- | 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
+  basicUnsafeSlice :: Int  -- ^ starting index
+                   -> Int  -- ^ length of the slice
+                   -> v s a
+                   -> v s a
 
   -- Check whether two vectors overlap. This method should not be
   -- called directly, use 'overlaps' instead.
@@ -133,7 +134,7 @@ class MVector v a where
   basicUnsafeGrow v by
     = do
         v' <- basicUnsafeNew (n+by)
-        basicUnsafeCopy (basicUnsafeSlice v' 0 n) v
+        basicUnsafeCopy (basicUnsafeSlice 0 n v') v
         return v'
     where
       n = length v
@@ -142,12 +143,13 @@ class MVector v a where
 
 -- | 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
+unsafeSlice :: MVector v a => Int  -- ^ starting index
+                           -> Int  -- ^ length of the slice
+                           -> v s a
+                           -> v s a
 {-# INLINE unsafeSlice #-}
-unsafeSlice v i n = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
-                  $ basicUnsafeSlice v i n
+unsafeSlice i n v = UNSAFE_CHECK(checkSlice) "unsafeSlice" i n (length v)
+                  $ basicUnsafeSlice i n v
 
 
 -- | Create a mutable vector of the given length. The length is not checked.
@@ -208,10 +210,10 @@ overlaps :: MVector v a => v s a -> v s a -> Bool
 overlaps = basicOverlaps
 
 -- | Yield a part of the mutable vector without copying it.
-slice :: MVector v a => v s a -> Int -> Int -> v s a
+slice :: MVector v a => Int -> Int -> v s a -> v s a
 {-# INLINE slice #-}
-slice v i n = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
-            $ unsafeSlice v i n
+slice i n v = BOUNDS_CHECK(checkSlice) "slice" i n (length v)
+            $ unsafeSlice i n v
 
 -- | Create a mutable vector of the given length.
 new :: (PrimMonad m, MVector v a) => Int -> m (v (PrimState m) a)
@@ -311,7 +313,7 @@ munstream :: (PrimMonad m, MVector v a)
 {-# INLINE munstream #-}
 munstream v s = v `seq` do
                           n' <- MStream.foldM put 0 s
-                          return $ unsafeSlice v 0 n'
+                          return $ unsafeSlice 0 n' v
   where
     {-# INLINE_INNER put #-}
     put i x = do
@@ -342,7 +344,7 @@ mrunstream :: (PrimMonad m, MVector v a)
 {-# INLINE mrunstream #-}
 mrunstream v s = v `seq` do
                            i <- MStream.foldM put n s
-                           return $ unsafeSlice v i (n-i)
+                           return $ unsafeSlice i (n-i) v
   where
     n = length v
 
@@ -378,7 +380,7 @@ unstreamMax s n
                          $ unsafeWrite v i x
                        return (i+1)
       n' <- Stream.foldM' put 0 s
-      return $ INTERNAL_CHECK(checkSlice) "unstreamMax" 0 n' n $ slice v 0 n'
+      return $ INTERNAL_CHECK(checkSlice) "unstreamMax" 0 n' n $ slice 0 n' v
 
 unstreamUnknown
   :: (PrimMonad m, MVector v a) => Stream a -> m (v (PrimState m) a)
@@ -387,7 +389,7 @@ unstreamUnknown s
   = do
       v <- new 0
       (v', n) <- Stream.foldM put (v, 0) s
-      return $ slice v' 0 n
+      return $ slice 0 n v'
   where
     {-# INLINE_INNER put #-}
     put (v,i) x = do
@@ -497,7 +499,7 @@ unstablePartitionMax f s n
                             return (i, j-1)
                                 
       (i,j) <- Stream.foldM' put (0, n) s
-      return (slice v 0 i, slice v j (n-j))
+      return (slice 0 i v, slice j (n-j) v)
 
 partitionUnknown :: (PrimMonad m, MVector v a)
         => (a -> Bool) -> Stream a -> m (v (PrimState m) a, v (PrimState m) a)
@@ -507,7 +509,7 @@ partitionUnknown f s
       v1 <- new 0
       v2 <- new 0
       (v1', n1, v2', n2) <- Stream.foldM' put (v1, 0, v2, 0) s
-      return (slice v1' 0 n1, slice v2' 0 n2)
+      return (slice 0 n1 v1', slice 0 n2 v2')
   where
     -- NOTE: The case distinction has to be on the outside because
     -- GHC creates a join point for the unsafeWrite even when everything
index a47e648..56645e6 100644 (file)
@@ -67,40 +67,40 @@ transform f (New p) = New (MVector.transform f =<< p)
 
  #-}
 
-slice :: New a -> Int -> Int -> New a
+slice :: Int -> Int -> New a -> New a
 {-# INLINE_STREAM slice #-}
-slice m i n = apply (\v -> MVector.slice v i n) m
+slice i n m = apply (MVector.slice i n) m
 
-unsafeSlice :: New a -> Int -> Int -> New a
+unsafeSlice :: Int -> Int -> New a -> New a
 {-# INLINE_STREAM unsafeSlice #-}
-unsafeSlice m i n = apply (\v -> MVector.unsafeSlice v i n) m
+unsafeSlice i n m = apply (MVector.unsafeSlice i n) m
 
 init :: New a -> New a
 {-# INLINE_STREAM init #-}
-init m = apply (\v -> MVector.slice v 0 (MVector.length v - 1)) m
+init m = apply (\v -> MVector.slice 0 (MVector.length v - 1) v) m
 
 tail :: New a -> New a
 {-# INLINE_STREAM tail #-}
-tail m = apply (\v -> MVector.slice v 1 (MVector.length v - 1)) m
+tail m = apply (\v -> MVector.slice 1 (MVector.length v - 1) v) m
 
 take :: Int -> New a -> New a
 {-# INLINE_STREAM take #-}
-take n m = apply (\v -> MVector.unsafeSlice 0
-                                (min (max 0 n) (MVector.length v))) m
+take n m = apply (\v -> MVector.unsafeSlice 0
+                                   (min (max 0 n) (MVector.length v)) v) m
 
 drop :: Int -> New a -> New a
 {-# INLINE_STREAM drop #-}
-drop n m = apply (\v -> MVector.unsafeSlice v
+drop n m = apply (\v -> MVector.unsafeSlice
                                 (min (max 0 n) (MVector.length v))
-                                (max 0 (MVector.length v - n))) m
+                                (max 0 (MVector.length v - n)) v) m
 
 {-# RULES
 
-"slice/unstream [New]" forall s i n.
-  slice (unstream s) i n = unstream (Stream.extract s i n)
+"slice/unstream [New]" forall i n s.
+  slice i n (unstream s) = unstream (Stream.slice i n s)
 
-"unsafeSlice/unstream [New]" forall s i n.
-  unsafeSlice (unstream s) i n = unstream (Stream.extract s i n)
+"unsafeSlice/unstream [New]" forall i n s.
+  unsafeSlice i n (unstream s) = unstream (Stream.slice i n s)
 
 "init/unstream [New]" forall s.
   init (unstream s) = unstream (Stream.init s)
index 93e5de1..95ff2c4 100644 (file)
@@ -46,7 +46,7 @@ instance G.MVector MVector a where
   basicLength (MVector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (MVector i n arr) j m = MVector (i+j) m arr
+  basicUnsafeSlice j m (MVector i n arr) = MVector (i+j) m arr
 
   {-# INLINE basicOverlaps #-}
   basicOverlaps (MVector i m arr1) (MVector j n arr2)
@@ -82,13 +82,13 @@ 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
+unsafeSlice :: Int  -- ^ starting index
+            -> Int  -- ^ length of the slice
+            -> MVector s a
+            -> 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 #-}
@@ -136,7 +136,7 @@ overlaps :: MVector s a -> MVector s a -> Bool
 overlaps = G.overlaps
 
 -- | Yield a part of the mutable vector without copying it.
-slice :: MVector s a -> Int -> Int -> MVector s a
+slice :: Int -> Int -> MVector s a -> MVector s a
 {-# INLINE slice #-}
 slice = G.slice
 
index a38116e..f570478 100644 (file)
@@ -117,7 +117,7 @@ instance Prim a => G.Vector Vector a where
   basicLength (Vector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (Vector i _ arr) j n = Vector (i+j) n arr
+  basicUnsafeSlice j n (Vector i _ arr) = Vector (i+j) n arr
 
   {-# INLINE basicUnsafeIndexM #-}
   basicUnsafeIndexM (Vector i _ arr) j = return (indexByteArray arr (i+j))
@@ -256,17 +256,19 @@ unsafeLastM = G.unsafeLastM
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'basicUnsafeSlice'.
-slice :: Prim a => Vector a -> Int   -- ^ starting index
-                            -> Int   -- ^ length
-                            -> Vector a
+slice :: Prim a => Int   -- ^ starting index
+                -> Int   -- ^ length
+                -> Vector a
+                -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
 -- | Unsafely yield a part of the vector without copying it and without
 -- performing bounds checks.
-unsafeSlice :: Prim a => Vector a -> Int   -- ^ starting index
-                                  -> Int   -- ^ length
-                                  -> Vector a
+unsafeSlice :: Prim a => Int   -- ^ starting index
+                      -> Int   -- ^ length
+                      -> Vector a
+                      -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
index 06a4321..c23b63f 100644 (file)
@@ -46,7 +46,7 @@ type STVector s = MVector s
 
 instance Prim a => G.MVector MVector a where
   basicLength (MVector _ n _) = n
-  basicUnsafeSlice (MVector i n arr) j m
+  basicUnsafeSlice j m (MVector i n arr)
     = MVector (i+j) m arr
 
   {-# INLINE basicOverlaps #-}
@@ -68,9 +68,10 @@ instance Prim a => G.MVector MVector a where
 
 -- | 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
+unsafeSlice :: Prim a => Int  -- ^ starting index
+                      -> Int  -- ^ length of the slice
+                      -> MVector s a   
+                      -> MVector s a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
@@ -125,7 +126,7 @@ overlaps :: Prim a => MVector s a -> MVector s a -> Bool
 overlaps = G.overlaps
 
 -- | Yield a part of the mutable vector without copying it.
-slice :: Prim a => MVector s a -> Int -> Int -> MVector s a
+slice :: Prim a => Int -> Int -> MVector s a -> MVector s a
 {-# INLINE slice #-}
 slice = G.slice
 
index 90d8e8a..e3c5ba5 100644 (file)
@@ -125,7 +125,7 @@ instance Storable a => G.Vector Vector a where
   basicLength (Vector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (Vector i _ p) j n = Vector (i+j) n p
+  basicUnsafeSlice j n (Vector i _ p) = Vector (i+j) n p
 
   {-# INLINE basicUnsafeIndexM #-}
   basicUnsafeIndexM (Vector i _ p) j = return
@@ -287,17 +287,19 @@ unsafeLastM = G.unsafeLastM
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'basicUnsafeSlice'.
-slice :: Storable a => Vector a -> Int   -- ^ starting index
-                                -> Int   -- ^ length
-                                -> Vector a
+slice :: Storable a => Int   -- ^ starting index
+                    -> Int   -- ^ length
+                    -> Vector a
+                    -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
 -- | Unsafely yield a part of the vector without copying it and without
 -- performing bounds checks.
-unsafeSlice :: Storable a => Vector a -> Int   -- ^ starting index
-                                      -> Int   -- ^ length
-                                      -> Vector a
+unsafeSlice :: Storable a => Int   -- ^ starting index
+                          -> Int   -- ^ length
+                          -> Vector a
+                          -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
index 5b0d9d2..4ad26d0 100644 (file)
@@ -48,7 +48,7 @@ instance Storable a => G.MVector MVector a where
   basicLength (MVector _ n _) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (MVector i n p) j m = MVector (i+j) m p
+  basicUnsafeSlice j m (MVector i n p) = MVector (i+j) m p
 
   -- FIXME: implement this properly
   {-# INLINE basicOverlaps #-}
@@ -72,13 +72,13 @@ instance Storable a => G.MVector MVector a where
 
 -- | 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
+unsafeSlice :: Storable a => Int  -- ^ starting index
+                          -> Int  -- ^ length of the slice
+                          -> MVector s a
+                          -> 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 #-}
@@ -131,7 +131,7 @@ overlaps :: Storable a => MVector s a -> MVector s a -> Bool
 overlaps = G.overlaps
 
 -- | Yield a part of the mutable vector without copying it.
-slice :: Storable a => MVector s a -> Int -> Int -> MVector s a
+slice :: Storable a => Int -> Int -> MVector s a -> MVector s a
 {-# INLINE slice #-}
 slice = G.slice
 
index 2804e0d..054b3da 100644 (file)
@@ -228,17 +228,19 @@ unsafeLastM = G.unsafeLastM
 
 -- | Yield a part of the vector without copying it. Safer version of
 -- 'basicUnsafeSlice'.
-slice :: Unbox a => Vector a -> Int   -- ^ starting index
-                            -> Int   -- ^ length
-                            -> Vector a
+slice :: Unbox a => Int   -- ^ starting index
+                 -> Int   -- ^ length
+                 -> Vector a
+                 -> Vector a
 {-# INLINE slice #-}
 slice = G.slice
 
 -- | Unsafely yield a part of the vector without copying it and without
 -- performing bounds checks.
-unsafeSlice :: Unbox a => Vector a -> Int   -- ^ starting index
-                                  -> Int   -- ^ length
-                                  -> Vector a
+unsafeSlice :: Unbox a => Int   -- ^ starting index
+                       -> Int   -- ^ length
+                       -> Vector a
+                       -> Vector a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
index 3311032..8ac2a80 100644 (file)
@@ -65,7 +65,7 @@ instance M.MVector MVector () where
 
   basicLength (MV_Unit n) = n
 
-  basicUnsafeSlice (MV_Unit n) i m = MV_Unit m
+  basicUnsafeSlice i m (MV_Unit n) = MV_Unit m
 
   basicOverlaps _ _ = False
 
@@ -91,7 +91,7 @@ instance G.Vector Vector () where
   basicLength (V_Unit n) = n
 
   {-# INLINE basicUnsafeSlice #-}
-  basicUnsafeSlice (V_Unit n) i m = V_Unit m
+  basicUnsafeSlice i m (V_Unit n) = V_Unit m
 
   {-# INLINE basicUnsafeIndexM #-}
   basicUnsafeIndexM (V_Unit _) i = return ()
@@ -118,7 +118,7 @@ instance M.MVector MVector ty where {                                   \
 ; {-# INLINE basicUnsafeCopy #-}                                        \
 ; {-# INLINE basicUnsafeGrow #-}                                        \
 ; basicLength (con v) = M.basicLength v                                 \
-; basicUnsafeSlice (con v) i n = con $ M.basicUnsafeSlice v i n         \
+; basicUnsafeSlice i n (con v) = con $ M.basicUnsafeSlice i n v         \
 ; 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         \
@@ -138,7 +138,7 @@ instance G.Vector Vector ty where {                                     \
 ; {-# INLINE elemseq #-}                                                \
 ; unsafeFreeze (mcon v) = con `liftM` G.unsafeFreeze v                  \
 ; basicLength (con v) = G.basicLength v                                 \
-; basicUnsafeSlice (con v) i n = con $ G.basicUnsafeSlice v i n         \
+; basicUnsafeSlice i n (con v) = con $ G.basicUnsafeSlice i n v         \
 ; basicUnsafeIndexM (con v) i = G.basicUnsafeIndexM v i                 \
 ; elemseq _ = seq }
 
@@ -255,7 +255,7 @@ instance M.MVector MVector Bool where
   {-# INLINE basicUnsafeCopy #-}
   {-# INLINE basicUnsafeGrow #-}
   basicLength (MV_Bool v) = M.basicLength v
-  basicUnsafeSlice (MV_Bool v) i n = MV_Bool $ M.basicUnsafeSlice v i n
+  basicUnsafeSlice i n (MV_Bool v) = MV_Bool $ M.basicUnsafeSlice i n v
   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)
@@ -274,7 +274,7 @@ instance G.Vector Vector Bool where
   {-# INLINE elemseq #-}
   unsafeFreeze (MV_Bool v) = V_Bool `liftM` G.unsafeFreeze v
   basicLength (V_Bool v) = G.basicLength v
-  basicUnsafeSlice (V_Bool v) i n = V_Bool $ G.basicUnsafeSlice v i n
+  basicUnsafeSlice i n (V_Bool v) = V_Bool $ G.basicUnsafeSlice i n v
   basicUnsafeIndexM (V_Bool v) i = toBool `liftM` G.basicUnsafeIndexM v i
   elemseq _ = seq
 
@@ -300,7 +300,7 @@ instance (RealFloat a, Unbox a) => M.MVector MVector (Complex a) where
   {-# INLINE basicUnsafeCopy #-}
   {-# INLINE basicUnsafeGrow #-}
   basicLength (MV_Complex v) = M.basicLength v
-  basicUnsafeSlice (MV_Complex v) i n = MV_Complex $ M.basicUnsafeSlice v i n
+  basicUnsafeSlice i n (MV_Complex v) = MV_Complex $ M.basicUnsafeSlice i n v
   basicOverlaps (MV_Complex v1) (MV_Complex v2) = M.basicOverlaps v1 v2
   basicUnsafeNew n = MV_Complex `liftM` M.basicUnsafeNew n
   basicUnsafeNewWith n (x :+ y) = MV_Complex `liftM` M.basicUnsafeNewWith n (x,y)
@@ -319,7 +319,7 @@ instance (RealFloat a, Unbox a) => G.Vector Vector (Complex a) where
   {-# INLINE elemseq #-}
   unsafeFreeze (MV_Complex v) = V_Complex `liftM` G.unsafeFreeze v
   basicLength (V_Complex v) = G.basicLength v
-  basicUnsafeSlice (V_Complex v) i n = V_Complex $ G.basicUnsafeSlice v i n
+  basicUnsafeSlice i n (V_Complex v) = V_Complex $ G.basicUnsafeSlice i n v
   basicUnsafeIndexM (V_Complex v) i
                 = uncurry (:+) `liftM` G.basicUnsafeIndexM v i
   elemseq _ (x :+ y) z = G.elemseq (undefined :: Vector a) x
index dc56217..17ca0bc 100644 (file)
@@ -34,13 +34,13 @@ import Prelude hiding ( zip, zip3, unzip, unzip3, length, read )
 
 -- | Yield a part of the mutable vector without copying it. No bounds checks
 -- are performed.
-unsafeSlice :: Unbox a => MVector s a -> Int  -- ^ starting index
-                                     -> Int  -- ^ length of the slice
-                                     -> MVector s a
+unsafeSlice :: Unbox a => Int  -- ^ starting index
+                       -> Int  -- ^ length of the slice
+                       -> MVector s a
+                       -> MVector s a
 {-# INLINE unsafeSlice #-}
 unsafeSlice = G.unsafeSlice
 
-
 -- | Create a mutable vector of the given length. The length is not checked.
 unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
 {-# INLINE unsafeNew #-}
@@ -91,7 +91,7 @@ overlaps :: Unbox a => MVector s a -> MVector s a -> Bool
 overlaps = G.overlaps
 
 -- | Yield a part of the mutable vector without copying it.
-slice :: Unbox a => MVector s a -> Int -> Int -> MVector s a
+slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
 {-# INLINE slice #-}
 slice = G.slice
 
index c176841..a0d203d 100644 (file)
@@ -64,9 +64,9 @@ generate n =
                    <+> con c
                    <+> text "len"
                    <+> sep [parens $ text "unsafeSlice"
-                                     <+> vs
                                      <+> char '0'
-                                     <+> text "len" | vs <- varss]
+                                     <+> text "len"
+                                     <+> vs | vs <- varss]
              ,nest 2 $ hang (text "where")
                             2
                      $ text "len ="
@@ -115,11 +115,11 @@ generate n =
     gen_length c _ = (pat c, var 'n')
 
     gen_unsafeSlice mod c rec
-      = (pat c <+> var 'i' <+> var 'm',
+      = (var 'i' <+> var 'm' <+> pat c,
          con c <+> var 'm'
                <+> vcat [parens
                          $ text mod <> char '.' <> text rec
-                                    <+> vs <+> var 'i' <+> var 'm'
+                                    <+> var 'i' <+> var 'm' <+> vs
                                         | vs <- varss])
 
 
index 584269e..fde1c3e 100644 (file)
@@ -10,9 +10,9 @@ instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
   {-# 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_)
+  basicUnsafeSlice i_ m_ (MV_2 n_ as bs)
+      = MV_2 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
   {-# INLINE basicOverlaps  #-}
   basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
       = M.basicOverlaps as1 as2
@@ -71,9 +71,9 @@ instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
   {-# INLINE basicLength  #-}
   basicLength (V_2 n_ as bs) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_2 n_ as bs) i_ m_
-      = V_2 m_ (G.basicUnsafeSlice as i_ m_)
-               (G.basicUnsafeSlice bs i_ m_)
+  basicUnsafeSlice i_ m_ (V_2 n_ as bs)
+      = V_2 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_2 n_ as bs) i_
       = do
@@ -89,7 +89,7 @@ instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
 zip :: (Unbox a, Unbox b) => MVector s a ->
                              MVector s b -> MVector s (a, b)
 {-# INLINE_STREAM zip #-}
-zip as bs = MV_2 len (unsafeSlice as 0 len) (unsafeSlice bs 0 len)
+zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
   where len = length as `min` length bs
 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
                                                     MVector s b)
@@ -99,7 +99,7 @@ unzip (MV_2 n_ as bs) = (as, bs)
 #ifdef DEFINE_IMMUTABLE
 zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
 {-# INLINE_STREAM zip #-}
-zip as bs = V_2 len (unsafeSlice as 0 len) (unsafeSlice bs 0 len)
+zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
   where len = length as `min` length bs
 {-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
   G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
@@ -126,10 +126,10 @@ instance (Unbox a,
   {-# 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_)
+  basicUnsafeSlice i_ m_ (MV_3 n_ as bs cs)
+      = MV_3 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
   {-# INLINE basicOverlaps  #-}
   basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
       = M.basicOverlaps as1 as2
@@ -200,10 +200,10 @@ instance (Unbox a,
   {-# INLINE basicLength  #-}
   basicLength (V_3 n_ as bs cs) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
-      = V_3 m_ (G.basicUnsafeSlice as i_ m_)
-               (G.basicUnsafeSlice bs i_ m_)
-               (G.basicUnsafeSlice cs i_ m_)
+  basicUnsafeSlice i_ m_ (V_3 n_ as bs cs)
+      = V_3 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_3 n_ as bs cs) i_
       = do
@@ -222,9 +222,9 @@ zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
                                        MVector s b ->
                                        MVector s c -> MVector s (a, b, c)
 {-# INLINE_STREAM zip3 #-}
-zip3 as bs cs = MV_3 len (unsafeSlice as 0 len)
-                         (unsafeSlice bs 0 len)
-                         (unsafeSlice cs 0 len)
+zip3 as bs cs = MV_3 len (unsafeSlice 0 len as)
+                         (unsafeSlice 0 len bs)
+                         (unsafeSlice 0 len cs)
   where len = length as `min` length bs `min` length cs
 unzip3 :: (Unbox a,
            Unbox b,
@@ -239,9 +239,9 @@ zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
                                        Vector b ->
                                        Vector c -> Vector (a, b, c)
 {-# INLINE_STREAM zip3 #-}
-zip3 as bs cs = V_3 len (unsafeSlice as 0 len)
-                        (unsafeSlice bs 0 len)
-                        (unsafeSlice cs 0 len)
+zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
+                        (unsafeSlice 0 len bs)
+                        (unsafeSlice 0 len cs)
   where len = length as `min` length bs `min` length cs
 {-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
   G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
@@ -273,11 +273,11 @@ instance (Unbox a,
   {-# 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_)
+  basicUnsafeSlice i_ m_ (MV_4 n_ as bs cs ds)
+      = MV_4 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
   {-# INLINE basicOverlaps  #-}
   basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
       = M.basicOverlaps as1 as2
@@ -362,11 +362,11 @@ instance (Unbox a,
   {-# INLINE basicLength  #-}
   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.basicUnsafeSlice as i_ m_)
-               (G.basicUnsafeSlice bs i_ m_)
-               (G.basicUnsafeSlice cs i_ m_)
-               (G.basicUnsafeSlice ds i_ m_)
+  basicUnsafeSlice i_ m_ (V_4 n_ as bs cs ds)
+      = V_4 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
       = do
@@ -388,10 +388,10 @@ zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
                                                 MVector s c ->
                                                 MVector s d -> MVector s (a, b, c, d)
 {-# INLINE_STREAM zip4 #-}
-zip4 as bs cs ds = MV_4 len (unsafeSlice as 0 len)
-                            (unsafeSlice bs 0 len)
-                            (unsafeSlice cs 0 len)
-                            (unsafeSlice ds 0 len)
+zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as)
+                            (unsafeSlice 0 len bs)
+                            (unsafeSlice 0 len cs)
+                            (unsafeSlice 0 len ds)
   where
     len = length as `min` length bs `min` length cs `min` length ds
 unzip4 :: (Unbox a,
@@ -410,10 +410,10 @@ zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
                                                 Vector c ->
                                                 Vector d -> Vector (a, b, c, d)
 {-# INLINE_STREAM zip4 #-}
-zip4 as bs cs ds = V_4 len (unsafeSlice as 0 len)
-                           (unsafeSlice bs 0 len)
-                           (unsafeSlice cs 0 len)
-                           (unsafeSlice ds 0 len)
+zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as)
+                           (unsafeSlice 0 len bs)
+                           (unsafeSlice 0 len cs)
+                           (unsafeSlice 0 len ds)
   where
     len = length as `min` length bs `min` length cs `min` length ds
 {-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
@@ -458,12 +458,12 @@ instance (Unbox a,
   {-# 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_)
+  basicUnsafeSlice i_ m_ (MV_5 n_ as bs cs ds es)
+      = MV_5 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
+                (M.basicUnsafeSlice i_ m_ es)
   {-# INLINE basicOverlaps  #-}
   basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
                                                          bs2
@@ -564,12 +564,12 @@ instance (Unbox a,
   {-# INLINE basicLength  #-}
   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.basicUnsafeSlice as i_ m_)
-               (G.basicUnsafeSlice bs i_ m_)
-               (G.basicUnsafeSlice cs i_ m_)
-               (G.basicUnsafeSlice ds i_ m_)
-               (G.basicUnsafeSlice es i_ m_)
+  basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
+      = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
+               (G.basicUnsafeSlice i_ m_ es)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
       = do
@@ -598,11 +598,11 @@ zip5 :: (Unbox a,
                      MVector s d ->
                      MVector s e -> MVector s (a, b, c, d, e)
 {-# INLINE_STREAM zip5 #-}
-zip5 as bs cs ds es = MV_5 len (unsafeSlice as 0 len)
-                               (unsafeSlice bs 0 len)
-                               (unsafeSlice cs 0 len)
-                               (unsafeSlice ds 0 len)
-                               (unsafeSlice es 0 len)
+zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
+                               (unsafeSlice 0 len bs)
+                               (unsafeSlice 0 len cs)
+                               (unsafeSlice 0 len ds)
+                               (unsafeSlice 0 len es)
   where
     len = length as `min`
           length bs `min`
@@ -632,11 +632,11 @@ zip5 :: (Unbox a,
                      Vector d ->
                      Vector e -> Vector (a, b, c, d, e)
 {-# INLINE_STREAM zip5 #-}
-zip5 as bs cs ds es = V_5 len (unsafeSlice as 0 len)
-                              (unsafeSlice bs 0 len)
-                              (unsafeSlice cs 0 len)
-                              (unsafeSlice ds 0 len)
-                              (unsafeSlice es 0 len)
+zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
+                              (unsafeSlice 0 len bs)
+                              (unsafeSlice 0 len cs)
+                              (unsafeSlice 0 len ds)
+                              (unsafeSlice 0 len es)
   where
     len = length as `min`
           length bs `min`
@@ -696,13 +696,13 @@ instance (Unbox a,
   {-# 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_)
+  basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
+      = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
+                (M.basicUnsafeSlice i_ m_ es)
+                (M.basicUnsafeSlice i_ m_ fs)
   {-# INLINE basicOverlaps  #-}
   basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
                                                              bs2
@@ -816,13 +816,13 @@ instance (Unbox a,
   {-# INLINE basicLength  #-}
   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.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_)
+  basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
+      = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
+               (G.basicUnsafeSlice i_ m_ es)
+               (G.basicUnsafeSlice i_ m_ fs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
       = do
@@ -855,12 +855,12 @@ zip6 :: (Unbox a,
                      MVector s e ->
                      MVector s f -> MVector s (a, b, c, d, e, f)
 {-# INLINE_STREAM zip6 #-}
-zip6 as bs cs ds es fs = MV_6 len (unsafeSlice as 0 len)
-                                  (unsafeSlice bs 0 len)
-                                  (unsafeSlice cs 0 len)
-                                  (unsafeSlice ds 0 len)
-                                  (unsafeSlice es 0 len)
-                                  (unsafeSlice fs 0 len)
+zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
+                                  (unsafeSlice 0 len bs)
+                                  (unsafeSlice 0 len cs)
+                                  (unsafeSlice 0 len ds)
+                                  (unsafeSlice 0 len es)
+                                  (unsafeSlice 0 len fs)
   where
     len = length as `min`
           length bs `min`
@@ -895,12 +895,12 @@ zip6 :: (Unbox a,
                      Vector e ->
                      Vector f -> Vector (a, b, c, d, e, f)
 {-# INLINE_STREAM zip6 #-}
-zip6 as bs cs ds es fs = V_6 len (unsafeSlice as 0 len)
-                                 (unsafeSlice bs 0 len)
-                                 (unsafeSlice cs 0 len)
-                                 (unsafeSlice ds 0 len)
-                                 (unsafeSlice es 0 len)
-                                 (unsafeSlice fs 0 len)
+zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
+                                 (unsafeSlice 0 len bs)
+                                 (unsafeSlice 0 len cs)
+                                 (unsafeSlice 0 len ds)
+                                 (unsafeSlice 0 len es)
+                                 (unsafeSlice 0 len fs)
   where
     len = length as `min`
           length bs `min`