zip6

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

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 zip6 function takes six lists and returns a list of six-tuples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => v a -> v b -> v c -> v d -> v e -> v f -> v (a, b, c, d, e, f)

rio RIO.Vector

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

rio RIO.Vector.Boxed

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

rio RIO.Vector.Unboxed

O(1) Zip 6 vectors

zip6 :: (Shape sh, Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Array U sh a -> Array U sh b -> Array U sh c -> Array U sh d -> Array U sh e -> Array U sh f -> Array U sh (a, b, c, d, e, f)

repa Data.Array.Repa.Repr.Unboxed

O(1). Zip some unboxed arrays. The shapes must be identical else error.

zip6 :: Zip6 f => f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)

classy-prelude ClassyPrelude, chunked-data Data.ChunkedZip

zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n e -> Vector v n f -> Vector v n (a, b, c, d, e, f)

vector-sized Data.Vector.Generic.Sized

zip6 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

vector-sized Data.Vector.Sized

zip6 :: (Storable a, Storable b, Storable c, Storable d, Storable e, Storable f, Storable (a, b, c, d, e, f)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

vector-sized Data.Vector.Storable.Sized

zip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e -> Vector n f -> Vector n (a, b, c, d, e, f)

vector-sized Data.Vector.Unboxed.Sized

zip6 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e -> Vec n f -> Vec n (a, b, c, d, e, f)

clash-prelude Clash.Explicit.Prelude Clash.Explicit.Prelude.Safe Clash.Prelude Clash.Prelude.Safe Clash.Sized.Vector

zip6 takes six vectors and returns a list of six-tuples, analogous to zip.

zip6 :: (BoxedZippable col, Sequential a, Sequential b, Sequential c, Sequential d, Sequential e, Sequential f, Element col ~ (Element a, Element b, Element c, Element d, Element e, Element f)) => a -> b -> c -> d -> e -> f -> col

foundation Foundation.Collection

Like zip, but works with 6 collections.

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

prelude-compat Data.List2010

zip6 :: Infinite a -> Infinite b -> Infinite c -> Infinite d -> Infinite e -> Infinite f -> Infinite (a, b, c, d, e, f)

infinite-list Data.List.Infinite

Zip six infinite lists.

zip6 :: (Context a, Context b, Context c, Context d, Context e, Context f, Context (a, b, c, d, e, f)) => Matrix a -> Matrix b -> Matrix c -> Matrix d -> Matrix e -> Matrix f -> Matrix (a, b, c, d, e, f)

matrices Data.Matrix Data.Matrix.Storable Data.Matrix.Unboxed

zip6 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e, Vector v f, Vector v (a, b, c, d, e, f)) => Matrix v a -> Matrix v b -> Matrix v c -> Matrix v d -> Matrix v e -> Matrix v f -> Matrix v (a, b, c, d, e, f)

matrices Data.Matrix.Generic

zip6 :: ([a], [b], [c], [d], [e], [f]) <-> [(a, b, c, d, e, f)]

invertible Data.Invertible.List

zip6 six lists together.

zip6 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector e -> NonEmptyVector f -> NonEmptyVector (a, b, c, d, e, f)

nonempty-vector Data.Vector.NonEmpty

Zip together six non-empty vectors.

zip6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)

unboxing-vector Data.Vector.Unboxing

zip6 :: (Unboxable a, Unboxable b, Unboxable c, Unboxable d, Unboxable e, Unboxable f) => MVector s a -> MVector s b -> MVector s c -> MVector s d -> MVector s e -> MVector s f -> MVector s (a, b, c, d, e, f)

unboxing-vector Data.Vector.Unboxing.Mutable

zip6 :: Monad m => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e -> Stream m f -> Stream m (a, b, c, d, e, f)

vector-stream Data.Stream.Monadic

type family Zip6 (a1 :: [a]) (a2 :: [b]) (a3 :: [c]) (a4 :: [d]) (a5 :: [e]) (a6 :: [f]) :: [(a, b, c, d, e, f)]

singletons-base Data.List.Singletons

type family Zip6 (a :: [k0]) (b :: [k1]) (c :: [k2]) (d :: [k3]) (e :: [k4]) (f :: [k5]) :: [(k0, k1, k2, k3, k4, k5)]

typelevel-tools-yj Data.TypeLevel.List.Zip

class Functor f => Zip6 f

chunked-data Data.ChunkedZip

data Zip6Sym0 (a1 :: TyFun [a] [b] ~> [c] ~> [d] ~> [e] ~> [f] ~> [(a, b, c, d, e, f)])

singletons-base Data.List.Singletons