INLINE_STREAM -> INLINE_FUSED
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
index fde1c3e..a9e6501 100644 (file)
@@ -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,19 +55,30 @@ 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  #-}
@@ -80,31 +91,40 @@ instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
           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) x_
-      = G.elemseq (undefined :: Vector a) a $
-        G.elemseq (undefined :: Vector b) b $ x_
+  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 #-}
+{-# INLINE_FUSED zip #-}
 zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
-  where len = length as `min` length 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 #-}
+{-# INLINE_FUSED zip #-}
 zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
-  where len = length as `min` length 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 #-}
@@ -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,23 +200,36 @@ 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  #-}
@@ -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) x_
-      = G.elemseq (undefined :: Vector a) a $
-        G.elemseq (undefined :: Vector b) b $
-        G.elemseq (undefined :: Vector c) c $ x_
+  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 #-}
+{-# 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 `min` length bs `min` length 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 #-}
+{-# 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 `min` length bs `min` length 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)
@@ -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,26 +384,44 @@ 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  #-}
@@ -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) x_
-      = G.elemseq (undefined :: Vector a) a $
-        G.elemseq (undefined :: Vector b) b $
-        G.elemseq (undefined :: Vector c) c $
-        G.elemseq (undefined :: Vector d) d $ x_
+  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 #-}
+{-# 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
+    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 #-}
+{-# 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
+    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,
@@ -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,29 +621,50 @@ 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  #-}
@@ -579,15 +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) x_
-      = 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 $ x_
+  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,
@@ -597,18 +714,19 @@ zip5 :: (Unbox a,
                      MVector s c ->
                      MVector s d ->
                      MVector s e -> MVector s (a, b, c, d, e)
-{-# INLINE_STREAM zip5 #-}
+{-# 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
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -622,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,
@@ -631,17 +750,17 @@ zip5 :: (Unbox a,
                      Vector c ->
                      Vector d ->
                      Vector e -> Vector (a, b, c, d, e)
-{-# INLINE_STREAM zip5 #-}
+{-# 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 [Vector.Unboxed]" forall as bs cs ds es .
   G.stream (zip5 as
@@ -654,6 +773,7 @@ zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
                                                  (G.stream ds)
                                                  (G.stream es)
   #-}
+-- | /O(1)/ Unzip 5 vectors
 unzip5 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -726,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_
@@ -787,32 +907,56 @@ 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  #-}
@@ -833,16 +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) x_
-      = 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 $ x_
+  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,
@@ -854,7 +1013,7 @@ zip6 :: (Unbox a,
                      MVector s d ->
                      MVector s e ->
                      MVector s f -> MVector s (a, b, c, d, e, f)
-{-# INLINE_STREAM zip6 #-}
+{-# 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)
@@ -862,12 +1021,13 @@ zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
                                   (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
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,
@@ -883,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,
@@ -894,7 +1055,7 @@ zip6 :: (Unbox a,
                      Vector d ->
                      Vector e ->
                      Vector f -> Vector (a, b, c, d, e, f)
-{-# INLINE_STREAM zip6 #-}
+{-# 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)
@@ -902,11 +1063,11 @@ zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
                                  (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 [Vector.Unboxed]" forall as bs cs ds es fs .
   G.stream (zip6 as
@@ -921,6 +1082,7 @@ zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
                                                    (G.stream es)
                                                    (G.stream fs)
   #-}
+-- | /O(1)/ Unzip 6 vectors
 unzip6 :: (Unbox a,
            Unbox b,
            Unbox c,