zip5 -package:singletons-base

zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

base Data.List, rio RIO.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 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v (a, b, c, d, e)) => v a -> v b -> v c -> v d -> v e -> v (a, b, c, d, e)

rio RIO.Vector

zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)

rio RIO.Vector.Boxed

zip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)

rio RIO.Vector.Unboxed

O(1) Zip 5 vectors

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 (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