zip4 -package:base

zip4 :: Seq a -> Seq b -> Seq c -> Seq d -> Seq (a, b, c, d)

containers Data.Sequence Data.Sequence.Internal, rio RIO.Seq

zip4 takes four sequences and returns a sequence of quadruples, analogous to zip.

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

rio RIO.List, base-prelude BasePrelude, ihaskell IHaskellPrelude, ghc-internal GHC.Internal.Data.List GHC.Internal.Data.OldList, rebase Rebase.Prelude, xmonad-contrib XMonad.Prelude

The zip4 function takes four lists and returns a list of quadruples, analogous to zip. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.

zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => v a -> v b -> v c -> v d -> v (a, b, c, d)

rio RIO.Vector

zip4 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)

rio RIO.Vector.Boxed

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

rio RIO.Vector.Unboxed

O(1) Zip 4 vectors

zip4 :: Zip f => f a -> f b -> f c -> f d -> f (a, b, c, d)

non-empty Data.NonEmpty.Class

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

repa Data.Array.Repa.Repr.Unboxed

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

zip4 :: Zip4 f => f a -> f b -> f c -> f d -> f (a, b, c, d)

classy-prelude ClassyPrelude, chunked-data Data.ChunkedZip

zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d -> Vector v n (a, b, c, d)

vector-sized Data.Vector.Generic.Sized

zip4 :: Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)

vector-sized Data.Vector.Sized

zip4 :: (Storable a, Storable b, Storable c, Storable d, Storable (a, b, c, d)) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)

vector-sized Data.Vector.Storable.Sized

zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)

vector-sized Data.Vector.Unboxed.Sized

zip4 :: (Index ix, Source r1 e1, Source r2 e2, Source r3 e3, Source r4 e4) => Array r1 ix e1 -> Array r2 ix e2 -> Array r3 ix e3 -> Array r4 ix e4 -> Array D ix (e1, e2, e3, e4)

massiv Data.Massiv.Array

Zip four arrays

zip4 :: ListN n a -> ListN n b -> ListN n c -> ListN n d -> ListN n (a, b, c, d)

basement Basement.Sized.List

Zip 4 lists of the same size

zip4 :: Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n (a, b, c, d)

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

zip4 takes four vectors and returns a list of quadruples, analogous to zip.

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

foundation Foundation.Collection

Like zip, but works with 4 collections.

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

prelude-compat Data.List2010

zip4 :: T a -> T b -> T c -> T d -> T (a, b, c, d)

synthesizer-core Synthesizer.State.Signal

zip4 :: (Functor m, Applicative m, Monad m) => Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m (a, b, c, d)

leveldb-haskell Data.Stream.Monadic

zip4 :: Infinite a -> Infinite b -> Infinite c -> Infinite d -> Infinite (a, b, c, d)

infinite-list Data.List.Infinite

Zip four infinite lists.

zip4 :: NESeq a -> NESeq b -> NESeq c -> NESeq d -> NESeq (a, b, c, d)

nonempty-containers Data.Sequence.NonEmpty

zip4 takes four sequences and returns a sequence of quadruples, analogous to zip.

zip4 :: (Context a, Context b, Context c, Context d, Context (a, b, c, d)) => Matrix a -> Matrix b -> Matrix c -> Matrix d -> Matrix (a, b, c, d)

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

zip4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v (a, b, c, d)) => Matrix v a -> Matrix v b -> Matrix v c -> Matrix v d -> Matrix v (a, b, c, d)

matrices Data.Matrix.Generic

zip4 :: ([a], [b], [c], [d]) <-> [(a, b, c, d)]

invertible Data.Invertible.List

zip4 four lists together.

zip4 :: NonEmptyVector a -> NonEmptyVector b -> NonEmptyVector c -> NonEmptyVector d -> NonEmptyVector (a, b, c, d)

nonempty-vector Data.Vector.NonEmpty

Zip together four non-empty vectors.