INLINE_STREAM -> INLINE_FUSED
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
index 8d826d8..a9e6501 100644 (file)
@@ -1,18 +1,18 @@
 #ifdef DEFINE_INSTANCES
 data instance MVector s (a, b)
-    = MV_2 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
+    = MV_2 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
 data instance Vector (a, b)
-    = V_2 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
+    = V_2 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
 instance (Unbox a, Unbox b) => Unbox (a, b)
 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
@@ -23,11 +23,11 @@ instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
           as <- M.basicUnsafeNew n_
           bs <- M.basicUnsafeNew n_
           return $ MV_2 n_ as bs
-  {-# INLINE basicUnsafeNewWith  #-}
-  basicUnsafeNewWith n_ (a, b)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b)
       = do
-          as <- M.basicUnsafeNewWith n_ a
-          bs <- M.basicUnsafeNewWith n_ b
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
           return $ MV_2 n_ as bs
   {-# INLINE basicUnsafeRead  #-}
   basicUnsafeRead (MV_2 n_ as bs) i_
@@ -55,56 +55,76 @@ instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
       = do
           M.basicUnsafeCopy as1 as2
           M.basicUnsafeCopy bs1 bs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove 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
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          return $ MV_2 (m_+n_) as' bs'
 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_2 n_ as bs)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_2 n_ as bs)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
           return $ V_2 n_ as' bs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_2 n_ as bs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          return $ MV_2 n_ as' bs'
   {-# 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
           a <- G.basicUnsafeIndexM as i_
           b <- G.basicUnsafeIndexM bs i_
           return (a, b)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_2 n_1 as1 bs1) (V_2 n_2 as2 bs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 2 vectors
 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)
-  where len = length as `min` length bs
-{-# RULES "stream/zip" forall as bs .
-  G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
-                                            (G.stream bs)
-  #-}
+{-# INLINE_FUSED zip #-}
+zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
+  where len = length as `delayed_min` length bs
+-- | /O(1)/ Unzip 2 vectors
 unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
                                                     MVector s b)
 {-# INLINE unzip #-}
 unzip (MV_2 n_ as bs) = (as, bs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 2 vectors
 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)
-  where len = length as `min` length bs
-{-# RULES "stream/zip" forall as bs .
+{-# INLINE_FUSED zip #-}
+zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
+  where len = length as `delayed_min` length bs
+{-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
   G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
                                             (G.stream bs)
   #-}
+-- | /O(1)/ Unzip 2 vectors
 unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
                                                  Vector b)
 {-# INLINE unzip #-}
@@ -112,13 +132,13 @@ unzip (V_2 n_ as bs) = (as, bs)
 #endif
 #ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c)
-    = MV_3 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
+    = MV_3 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
 data instance Vector (a, b, c)
-    = V_3 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
+    = V_3 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
 instance (Unbox a,
           Unbox b,
@@ -126,10 +146,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
@@ -142,12 +162,12 @@ instance (Unbox a,
           bs <- M.basicUnsafeNew n_
           cs <- M.basicUnsafeNew n_
           return $ MV_3 n_ as bs cs
-  {-# INLINE basicUnsafeNewWith  #-}
-  basicUnsafeNewWith n_ (a, b, c)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c)
       = do
-          as <- M.basicUnsafeNewWith n_ a
-          bs <- M.basicUnsafeNewWith n_ b
-          cs <- M.basicUnsafeNewWith n_ c
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
           return $ MV_3 n_ as bs cs
   {-# INLINE basicUnsafeRead  #-}
   basicUnsafeRead (MV_3 n_ as bs cs) i_
@@ -180,30 +200,43 @@ instance (Unbox a,
           M.basicUnsafeCopy as1 as2
           M.basicUnsafeCopy bs1 bs2
           M.basicUnsafeCopy cs1 cs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove 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
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          return $ MV_3 (m_+n_) as' bs' cs'
 instance (Unbox a,
           Unbox b,
           Unbox c) => G.Vector Vector (a, b, c) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_3 n_ as bs cs)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_3 n_ as bs cs)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
           return $ V_3 n_ as' bs' cs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_3 n_ as bs cs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          return $ MV_3 n_ as' bs' cs'
   {-# 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
@@ -211,21 +244,30 @@ instance (Unbox a,
           b <- G.basicUnsafeIndexM bs i_
           c <- G.basicUnsafeIndexM cs i_
           return (a, b, c)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (V_3 n_2 as2 bs2 cs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 3 vectors
 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)
-  where len = length as `min` length bs `min` length cs
-{-# RULES "stream/zip3" forall as bs cs .
-  G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
-                                                   (G.stream bs)
-                                                   (G.stream cs)
-  #-}
+{-# INLINE_FUSED zip3 #-}
+zip3 as bs cs = MV_3 len (unsafeSlice 0 len as)
+                         (unsafeSlice 0 len bs)
+                         (unsafeSlice 0 len cs)
+  where
+    len = length as `delayed_min` length bs `delayed_min` length cs
+-- | /O(1)/ Unzip 3 vectors
 unzip3 :: (Unbox a,
            Unbox b,
            Unbox c) => MVector s (a, b, c) -> (MVector s a,
@@ -235,19 +277,22 @@ unzip3 :: (Unbox a,
 unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 3 vectors
 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)
-  where len = length as `min` length bs `min` length cs
-{-# RULES "stream/zip3" forall as bs cs .
+{-# INLINE_FUSED zip3 #-}
+zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
+                        (unsafeSlice 0 len bs)
+                        (unsafeSlice 0 len cs)
+  where
+    len = length as `delayed_min` length bs `delayed_min` length cs
+{-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
   G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
                                                    (G.stream bs)
                                                    (G.stream cs)
   #-}
+-- | /O(1)/ Unzip 3 vectors
 unzip3 :: (Unbox a,
            Unbox b,
            Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
@@ -256,15 +301,15 @@ unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
 #endif
 #ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d)
-    = MV_4 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
+    = MV_4 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
 data instance Vector (a, b, c, d)
-    = V_4 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
+    = V_4 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
 instance (Unbox a,
           Unbox b,
@@ -273,11 +318,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
@@ -292,13 +337,13 @@ instance (Unbox a,
           cs <- M.basicUnsafeNew n_
           ds <- M.basicUnsafeNew n_
           return $ MV_4 n_ as bs cs ds
-  {-# INLINE basicUnsafeNewWith  #-}
-  basicUnsafeNewWith n_ (a, b, c, d)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d)
       = do
-          as <- M.basicUnsafeNewWith n_ a
-          bs <- M.basicUnsafeNewWith n_ b
-          cs <- M.basicUnsafeNewWith n_ c
-          ds <- M.basicUnsafeNewWith n_ d
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
           return $ MV_4 n_ as bs cs ds
   {-# INLINE basicUnsafeRead  #-}
   basicUnsafeRead (MV_4 n_ as bs cs ds) i_
@@ -339,34 +384,52 @@ instance (Unbox a,
           M.basicUnsafeCopy bs1 bs2
           M.basicUnsafeCopy cs1 cs2
           M.basicUnsafeCopy ds1 ds2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
+                                                       bs2
+                                                       cs2
+                                                       ds2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove 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
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          return $ MV_4 (m_+n_) as' bs' cs' ds'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d) => G.Vector Vector (a, b, c, d) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_4 n_ as bs cs ds)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_4 n_ as bs cs ds)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
           return $ V_4 n_ as' bs' cs' ds'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_4 n_ as bs cs ds)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          return $ MV_4 n_ as' bs' cs' ds'
   {-# 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
@@ -375,25 +438,40 @@ instance (Unbox a,
           c <- G.basicUnsafeIndexM cs i_
           d <- G.basicUnsafeIndexM ds i_
           return (a, b, c, d)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (V_4 n_2 as2
+                                                      bs2
+                                                      cs2
+                                                      ds2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 4 vectors
 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
                                                 MVector s b ->
                                                 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)
+{-# INLINE_FUSED zip4 #-}
+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
-{-# RULES "stream/zip4" forall as bs cs ds .
-  G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as)
-                                                        (G.stream bs)
-                                                        (G.stream cs)
-                                                        (G.stream ds)
-  #-}
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds
+-- | /O(1)/ Unzip 4 vectors
 unzip4 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -405,23 +483,28 @@ unzip4 :: (Unbox a,
 unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 4 vectors
 zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
                                                 Vector b ->
                                                 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)
+{-# INLINE_FUSED zip4 #-}
+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" forall as bs cs ds .
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds
+{-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
   G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as)
                                                         (G.stream bs)
                                                         (G.stream cs)
                                                         (G.stream ds)
   #-}
+-- | /O(1)/ Unzip 4 vectors
 unzip4 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -434,17 +517,17 @@ unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
 #endif
 #ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d, e)
-    = MV_5 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
+    = MV_5 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
+                               !(MVector s e)
 data instance Vector (a, b, c, d, e)
-    = V_5 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
+    = V_5 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
+                              !(Vector e)
 instance (Unbox a,
           Unbox b,
           Unbox c,
@@ -458,12 +541,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
@@ -484,14 +567,14 @@ instance (Unbox a,
           ds <- M.basicUnsafeNew n_
           es <- M.basicUnsafeNew n_
           return $ MV_5 n_ as bs cs ds es
-  {-# 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
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d, e)
+      = do
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
+          es <- M.basicUnsafeReplicate n_ e
           return $ MV_5 n_ as bs cs ds es
   {-# INLINE basicUnsafeRead  #-}
   basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
@@ -538,38 +621,59 @@ instance (Unbox a,
           M.basicUnsafeCopy cs1 cs2
           M.basicUnsafeCopy ds1 ds2
           M.basicUnsafeCopy es1 es2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                           bs2
+                                                           cs2
+                                                           ds2
+                                                           es2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove ds1 ds2
+          M.basicUnsafeMove 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
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          es' <- M.basicUnsafeGrow es m_
+          return $ MV_5 (m_+n_) as' bs' cs' ds' es'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d,
           Unbox e) => G.Vector Vector (a, b, c, d, e) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_5 n_ as bs cs ds es)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
+      = do
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
+          es' <- G.basicUnsafeFreeze es
           return $ V_5 n_ as' bs' cs' ds' es'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_5 n_ as bs cs ds es)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          return $ MV_5 n_ as' bs' cs' ds' es'
   {-# 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
@@ -579,8 +683,28 @@ instance (Unbox a,
           d <- G.basicUnsafeIndexM ds i_
           e <- G.basicUnsafeIndexM es i_
           return (a, b, c, d, e)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
+                                                          bs2
+                                                          cs2
+                                                          ds2
+                                                          es2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+          G.basicUnsafeCopy es1 es2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d, e)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
+        . G.elemseq (undefined :: Vector e) e
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 5 vectors
 zip5 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -590,29 +714,19 @@ zip5 :: (Unbox a,
                      MVector s c ->
                      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)
+{-# INLINE_FUSED zip5 #-}
+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`
-          length cs `min`
-          length ds `min`
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
           length es
-{-# RULES "stream/zip5" forall as bs cs ds es .
-  G.stream (zip5 as
-                 bs
-                 cs
-                 ds
-                 es) = Stream.zipWith5 (, , , ,) (G.stream as)
-                                                 (G.stream bs)
-                                                 (G.stream cs)
-                                                 (G.stream ds)
-                                                 (G.stream es)
-  #-}
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -626,6 +740,7 @@ unzip5 :: (Unbox a,
 unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 5 vectors
 zip5 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -635,19 +750,19 @@ zip5 :: (Unbox a,
                      Vector c ->
                      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)
+{-# INLINE_FUSED zip5 #-}
+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`
-          length cs `min`
-          length ds `min`
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
           length es
-{-# RULES "stream/zip5" forall as bs cs ds es .
+{-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
   G.stream (zip5 as
                  bs
                  cs
@@ -658,6 +773,7 @@ zip5 as bs cs ds es = V_5 len (unsafeSlice as 0 len)
                                                  (G.stream ds)
                                                  (G.stream es)
   #-}
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -672,19 +788,19 @@ unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
 #endif
 #ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d, e, f)
-    = MV_6 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
-                               (MVector s f)
+    = MV_6 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
+                               !(MVector s e)
+                               !(MVector s f)
 data instance Vector (a, b, c, d, e, f)
-    = V_6 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
-                              (Vector f)
+    = V_6 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
+                              !(Vector e)
+                              !(Vector f)
 instance (Unbox a,
           Unbox b,
           Unbox c,
@@ -700,13 +816,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
@@ -730,15 +846,15 @@ instance (Unbox a,
           es <- M.basicUnsafeNew n_
           fs <- M.basicUnsafeNew n_
           return $ MV_6 n_ as bs cs ds es fs
-  {-# 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
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d, e, f)
+      = do
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
+          es <- M.basicUnsafeReplicate n_ e
+          fs <- M.basicUnsafeReplicate n_ f
           return $ MV_6 n_ as bs cs ds es fs
   {-# INLINE basicUnsafeRead  #-}
   basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
@@ -791,42 +907,66 @@ instance (Unbox a,
           M.basicUnsafeCopy ds1 ds2
           M.basicUnsafeCopy es1 es2
           M.basicUnsafeCopy fs1 fs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                               bs2
+                                                               cs2
+                                                               ds2
+                                                               es2
+                                                               fs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove ds1 ds2
+          M.basicUnsafeMove es1 es2
+          M.basicUnsafeMove 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
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          es' <- M.basicUnsafeGrow es m_
+          fs' <- M.basicUnsafeGrow fs m_
+          return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d,
           Unbox e,
           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_6 n_ as bs cs ds es fs)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
+      = do
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
+          es' <- G.basicUnsafeFreeze es
+          fs' <- G.basicUnsafeFreeze fs
           return $ V_6 n_ as' bs' cs' ds' es' fs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          fs' <- G.basicUnsafeThaw fs
+          return $ MV_6 n_ as' bs' cs' ds' es' fs'
   {-# 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
@@ -837,8 +977,31 @@ instance (Unbox a,
           e <- G.basicUnsafeIndexM es i_
           f <- G.basicUnsafeIndexM fs i_
           return (a, b, c, d, e, f)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
+                                                              bs2
+                                                              cs2
+                                                              ds2
+                                                              es2
+                                                              fs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+          G.basicUnsafeCopy es1 es2
+          G.basicUnsafeCopy fs1 fs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d, e, f)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
+        . G.elemseq (undefined :: Vector e) e
+        . G.elemseq (undefined :: Vector f) f
 #endif
 #ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 6 vectors
 zip6 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -850,33 +1013,21 @@ zip6 :: (Unbox a,
                      MVector s d ->
                      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)
+{-# INLINE_FUSED zip6 #-}
+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`
-          length cs `min`
-          length ds `min`
-          length es `min`
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es `delayed_min`
           length fs
-{-# RULES "stream/zip6" forall as bs cs ds es fs .
-  G.stream (zip6 as
-                 bs
-                 cs
-                 ds
-                 es
-                 fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
-                                                   (G.stream bs)
-                                                   (G.stream cs)
-                                                   (G.stream ds)
-                                                   (G.stream es)
-                                                   (G.stream fs)
-  #-}
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -892,6 +1043,7 @@ unzip6 :: (Unbox a,
 unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
 #endif
 #ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 6 vectors
 zip6 :: (Unbox a,
          Unbox b,
          Unbox c,
@@ -903,21 +1055,21 @@ zip6 :: (Unbox a,
                      Vector d ->
                      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)
+{-# INLINE_FUSED zip6 #-}
+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`
-          length cs `min`
-          length ds `min`
-          length es `min`
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es `delayed_min`
           length fs
-{-# RULES "stream/zip6" forall as bs cs ds es fs .
+{-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
   G.stream (zip6 as
                  bs
                  cs
@@ -930,6 +1082,7 @@ zip6 as bs cs ds es fs = V_6 len (unsafeSlice as 0 len)
                                                    (G.stream es)
                                                    (G.stream fs)
   #-}
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,