zip

zip :: [a] -> [b] -> [(a, b)]
base Prelude, base Data.List
zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
base Prelude, base Data.List
zip3 takes three lists and returns a list of triples, analogous to zip.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
base Prelude, base Data.List
zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
base Prelude, base Data.List
The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
base Data.List
The zip4 function takes four lists and returns a list of quadruples, analogous to zip.
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
base Data.List
The zip5 function takes five lists and returns a list of five-tuples, analogous to zip.
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
base Data.List
The zip6 function takes six lists and returns a list of six-tuples, analogous to zip.
zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
base Data.List
The zip7 function takes seven lists and returns a list of seven-tuples, analogous to zip.
ZipList :: [a] -> ZipList a
base Control.Applicative
newtype ZipList a
base Control.Applicative
Lists, but with an Applicative functor based on zipping, so that > f <$> ZipList xs1 <*> ... <*> ZipList xsn = ZipList (zipWithn f xs1 ... xsn)
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
base Data.List
The zipWith4 function takes a function which combines four elements, as well as four lists and returns a list of their point-wise combination, analogous to zipWith.
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
base Data.List
The zipWith5 function takes a function which combines five elements, as well as five lists and returns a list of their point-wise combination, analogous to zipWith.
zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
base Data.List
The zipWith6 function takes a function which combines six elements, as well as six lists and returns a list of their point-wise combination, analogous to zipWith.
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
base Data.List
The zipWith7 function takes a function which combines seven elements, as well as seven lists and returns a list of their point-wise combination, analogous to zipWith.
zipWithM :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m [c]
base Control.Monad
The zipWithM function generalizes zipWith to arbitrary monads.
zipWithM_ :: Monad m => (a -> b -> m c) -> [a] -> [b] -> m ()
base Control.Monad
zipWithM_ is the extension of zipWithM which ignores the final result.
zip :: ByteString -> ByteString -> [(Char, Char)]
bytestring Data.ByteString.Char8, bytestring Data.ByteString.Lazy.Char8
O(n) zip takes two ByteStrings and returns a list of corresponding pairs of Chars. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of unpack operations, and so space usage may be large for multi-megabyte ByteStrings
zip :: ByteString -> ByteString -> [(Word8, Word8)]
bytestring Data.ByteString, bytestring Data.ByteString.Lazy
O(n) zip takes two ByteStrings and returns a list of corresponding pairs of bytes. If one input ByteString is short, excess elements of the longer ByteString are discarded. This is equivalent to a pair of unpack operations.
zip :: Seq a -> Seq b -> Seq (a, b)
containers Data.Sequence
O(min(n1,n2)). zip takes two sequences and returns a sequence of corresponding pairs. If one input is short, excess elements are discarded from the right end of the longer sequence.
zip :: Text -> Text -> [(Char, Char)]
text Data.Text, text Data.Text.Lazy
O(n) zip takes two Texts and returns a list of corresponding pairs of bytes. If one input Text is short, excess elements of the longer Text are discarded. This is equivalent to a pair of unpack operations.

Show more results