zip5 -package:rio

zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
base Data.List, base-prelude BasePrelude, ghc-internal GHC.Internal.Data.List GHC.Internal.Data.OldList, rebase Rebase.Prelude, xmonad-contrib XMonad.Prelude, LambdaHack Game.LambdaHack.Core.Prelude
The zip5 function takes five lists and returns a list of five-tuples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.
zip5 :: (Shape sh, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Array U sh a -> Array U sh b -> Array U sh c -> Array U sh d -> Array U sh e -> Array U sh (a, b, c, d, e)
repa Data.Array.Repa.Repr.Unboxed
O(1). Zip some unboxed arrays. The shapes must be identical else error.
zip5 :: Zip5 f => f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
classy-prelude ClassyPrelude, chunked-data Data.ChunkedZip
zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n (a, b, c, d, e)
vector-sized Data.Vector.Generic.Sized
zip5 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
vector-sized Data.Vector.Sized
zip5 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable (a, b, c, d, e)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
vector-sized Data.Vector.Storable.Sized
zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n (a, b, c, d, e)
vector-sized Data.Vector.Unboxed.Sized
zip5 :: ListN n a -> ListN n b -> ListN n c -> ListN n d -> ListN n e -> ListN n (a, b, c, d, e)
basement Basement.Sized.List
Zip 5 lists of the same size
zip5 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n (a, b, c, d, e)
clash-prelude Clash.Explicit.Prelude Clash.Explicit.Prelude.Safe Clash.Prelude Clash.Prelude.Safe Clash.Sized.Vector
zip5 takes five vectors and returns a list of five-tuples, analogous to zip.
zip5 :: (BoxedZippable col, Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Element col ~ (Element a, Element b, Element c, Element d, Element e)) => a -> b -> c -> d -> e -> col
foundation Foundation.Collection
Like zip, but works with 5 collections.
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
prelude-compat Data.List2010
zip5 :: Infinite a -> Infinite b -> Infinite c -> Infinite d -> Infinite e -> Infinite (a, b, c, d, e)
infinite-list Data.List.Infinite
Zip five infinite lists.
zip5 :: (Context a, Context b, Context c, Context d, Context e, Context (a, b, c, d, e)) => Matrix a -> Matrix b -> Matrix c -> Matrix d -> Matrix e -> Matrix (a, b, c, d, e)
matrices Data.Matrix Data.Matrix.Storable Data.Matrix.Unboxed
zip5 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => Matrix v a -> Matrix v b -> Matrix v c -> Matrix v d -> Matrix v e -> Matrix v (a, b, c, d, e)
matrices Data.Matrix.Generic
zip5 :: ([a], [b], [c], [d], [e]) <-> [(a, b, c, d, e)]
invertible Data.Invertible.List
zip5 five lists together.
zip5 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector (a, b, c, d, e)
nonempty-vector Data.Vector.NonEmpty
Zip together five non-empty vectors.
zip5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
unboxing-vector Data.Vector.Unboxing
zip5 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s (a, b, c, d, e)
unboxing-vector Data.Vector.Unboxing.Mutable
zip5 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m (a, b, c, d, e)
vector-stream Data.Stream.Monadic
type family Zip5 (a1 :: [a]) (a2 :: [b]) (a3 :: [c]) (a4 :: [d]) (a5 :: [e]) :: [(a, b, c, d, e)]
singletons-base Data.List.Singletons
type family Zip5 (a :: [k0]) (b :: [k1]) (c :: [k2]) (d :: [k3]) (e :: [k4]) :: [(k0, k1, k2, k3, k4)]
typelevel-tools-yj Data.TypeLevel.List.Zip
class Functor f => Zip5 f
chunked-data Data.ChunkedZip
zip5P :: Predicate a -> Predicate b -> Predicate c -> Predicate d -> Predicate e -> Predicate (a, b, c, d, e)
explainable-predicates Test.Predicates
A Predicate that accepts 3-tuples whose elements satisfy the corresponding child Predicates. 
>>> accept (zip5P (eq 1) (eq 2) (eq 3) (eq 4) (eq 5)) (1, 2, 3, 4, 5)
True

>>> accept (zip5P (eq 1) (eq 2) (eq 3) (eq 4) (eq 5)) (5, 4, 3, 2, 1)
False
data Zip5Sym0 (a1 :: TyFun [a] [b] ~> [c] ~> [d] ~> [e] ~> [(a, b, c, d, e)])
singletons-base Data.List.Singletons
data Zip5Sym1 (a6989586621679656263 :: [a]) (b1 :: TyFun [b] [c] ~> [d] ~> [e] ~> [(a, b, c, d, e)])
singletons-base Data.List.Singletons