-- Zipping
-- -------

--   -- | /O(min(m,n))/ Zip two vectors with the given function.
--   zipWith :: ( G.Vector u a, G.Vector v a'
--              , G.Vector u b, G.Vector v b'
--              , G.Vector u c, G.Vector v c'
--              ) => ((a,a') -> (b,b') -> (c,c'))
--                -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c')
--   zipWith = G.zipWith
--   {-# INLINE zipWith #-}
--
--   -- | Zip three vectors with the given function.
--
--   zipWith3 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               ) => ((a,a') -> (b,b') -> (c,c') -> (d, d'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d')
--   zipWith3 = G.zipWith3
--   {-# INLINE zipWith3 #-}
--
--   zipWith4 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               ) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e')
--   zipWith4 = G.zipWith4
--   {-# INLINE zipWith4 #-}
--
--   zipWith5 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               , G.Vector u f, G.Vector v f'
--               ) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e') -> (Vector k) u v (f,f')
--   zipWith5 = G.zipWith5
--   {-# INLINE zipWith5 #-}
--
--   zipWith6 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               , G.Vector u f, G.Vector v f'
--               , G.Vector u g, G.Vector v g'
--               ) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f') -> (g,g'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e') -> (Vector k) u v (f,f') -> (Vector k) u v (g,g')
--   zipWith6 = G.zipWith6
--   {-# INLINE zipWith6 #-}
--
--   -- | /O(min(m,n))/ Zip two vectors with a function that also takes the
--   -- elements' indices.
--   izipWith :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               ) => (Int -> (a,a') -> (b,b') -> (c,c'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c')
--   izipWith = G.izipWith
--   {-# INLINE izipWith #-}
--
--   -- | Zip three vectors and their indices with the given function.
--   izipWith3 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               ) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d')
--   izipWith3 = G.izipWith3
--   {-# INLINE izipWith3 #-}
--
--   izipWith4 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               ) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e')
--   izipWith4 = G.izipWith4
--   {-# INLINE izipWith4 #-}
--
--   izipWith5 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               , G.Vector u f, G.Vector v f'
--               ) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e') -> (Vector k) u v (f,f')
--   izipWith5 = G.izipWith5
--   {-# INLINE izipWith5 #-}
--
--   izipWith6 :: ( G.Vector u a, G.Vector v a'
--               , G.Vector u b, G.Vector v b'
--               , G.Vector u c, G.Vector v c'
--               , G.Vector u d, G.Vector v d'
--               , G.Vector u e, G.Vector v e'
--               , G.Vector u f, G.Vector v f'
--               , G.Vector u g, G.Vector v g'
--               ) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f') -> (g,g'))
--                 -> (Vector k) u v (a,a') -> (Vector k) u v (b,b') -> (Vector k) u v (c,c') -> (Vector k) u v (d,d') -> (Vector k) u v (e,e') -> (Vector k) u v (f,f') -> (Vector k) u v (g,g')
--   izipWith6 = G.izipWith6
--   {-# INLINE izipWith6 #-}

-- Monadic zipping
-- ---------------

-- | /O(min(m,n))/ Zip the two vectors with the monadic action and yield a
-- vector of results
zipWithM :: (Monad m, G.Vector (Vector k) (Rec (TaggedFunctor Identity) rs), G.Vector (Vector k) (Rec (TaggedFunctor Identity) ss), G.Vector (Vector k) (Rec (TaggedFunctor Identity) ts))
         => (Rec (TaggedFunctor Identity) rs -> Rec (TaggedFunctor Identity) ss -> m (Rec (TaggedFunctor Identity) ts)) -> (Vector k) (Rec (TaggedFunctor Identity) rs) -> (Vector k) (Rec (TaggedFunctor Identity) ss) -> m ((Vector k) (Rec (TaggedFunctor Identity) ts))
zipWithM = G.zipWithM
zipWithM :: (Monad m, G.Vector (Vector k) (Rec (TaggedFunctor Identity) rs), G.Vector (Vector k) (Rec (TaggedFunctor Identity) ss), G.Vector (Vector k) (Rec (TaggedFunctor Identity) ts))
         => (Rec (TaggedFunctor Identity) rs -> Rec (TaggedFunctor Identity) ss -> m (Rec (TaggedFunctor Identity) ts)) -> (Vector k) (Rec (TaggedFunctor Identity) rs) -> (Vector k) (Rec (TaggedFunctor Identity) ss) -> m ((Vector k) (Rec (TaggedFunctor Identity) ts))
zipWithM = G.zipWithM
zipWithM = G.zipWithM