zip7

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

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

zip7 :: Zip7 f => f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)

classy-prelude ClassyPrelude, chunked-data Data.ChunkedZip

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

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

zip7 takes seven vectors and returns a list of seven-tuples, analogous to zip.

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

foundation Foundation.Collection

Like zip, but works with 7 collections.

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

prelude-compat Data.List2010

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

infinite-list Data.List.Infinite

Zip seven infinite lists.

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

invertible Data.Invertible.List

zip7 seven lists together.

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

singletons-base Data.List.Singletons

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

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

class Functor f => Zip7 f

chunked-data Data.ChunkedZip

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

singletons-base Data.List.Singletons

data Zip7Sym1 (a6989586621679656202 :: [a]) (b1 :: TyFun [b] [c] ~> [d] ~> [e] ~> [f] ~> [g] ~> [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

data Zip7Sym2 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (c1 :: TyFun [c] [d] ~> [e] ~> [f] ~> [g] ~> [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

data Zip7Sym3 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (a6989586621679656204 :: [c]) (d1 :: TyFun [d] [e] ~> [f] ~> [g] ~> [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

data Zip7Sym4 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (a6989586621679656204 :: [c]) (a6989586621679656205 :: [d]) (e1 :: TyFun [e] [f] ~> [g] ~> [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

data Zip7Sym5 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (a6989586621679656204 :: [c]) (a6989586621679656205 :: [d]) (a6989586621679656206 :: [e]) (f1 :: TyFun [f] [g] ~> [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

data Zip7Sym6 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (a6989586621679656204 :: [c]) (a6989586621679656205 :: [d]) (a6989586621679656206 :: [e]) (a6989586621679656207 :: [f]) (g1 :: TyFun [g] [(a, b, c, d, e, f, g)])

singletons-base Data.List.Singletons

type family Zip7Sym7 (a6989586621679656202 :: [a]) (a6989586621679656203 :: [b]) (a6989586621679656204 :: [c]) (a6989586621679656205 :: [d]) (a6989586621679656206 :: [e]) (a6989586621679656207 :: [f]) (a6989586621679656208 :: [g]) :: [(a, b, c, d, e, f, g)]

singletons-base Data.List.Singletons

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

base Data.List, rio RIO.List, base-prelude BasePrelude, ihaskell IHaskellPrelude

The unzip7 function takes a list of seven-tuples and returns seven lists, analogous to unzip.

unzip7 :: Zip7 f => f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)

classy-prelude ClassyPrelude

type family Unzip7 (a1 :: [(a, b, c, d, e, f, g)]) :: ([a], [b], [c], [d], [e], [f], [g])

singletons-base Data.List.Singletons

data Unzip7Sym0 (a1 :: TyFun [(a, b, c, d, e, f, g)] ([a], [b], [c], [d], [e], [f], [g]))

singletons-base Data.List.Singletons

type family Unzip7Sym1 (a6989586621679544824 :: [(a, b, c, d, e, f, g)]) :: ([a], [b], [c], [d], [e], [f], [g])

singletons-base Data.List.Singletons

sUnzip7 :: forall a b c d e f g (t :: [(a, b, c, d, e, f, g)]) . Sing t -> Sing (Unzip7 t)

singletons-base Data.List.Singletons

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

clash-prelude Clash.Explicit.Prelude

unzip7 takes a vector of seven-tuples and returns seven vectors, analogous to unzip.