zipWith4 -package:base

zipWith4 :: (a -> b -> c -> d -> e) -> Seq a -> Seq b -> Seq c -> Seq d -> Seq e
containers Data.Sequence Data.Sequence.Internal, rio RIO.Seq
zipWith4 takes a function which combines four elements, as well as four sequences and returns a sequence of their point-wise combinations, analogous to zipWith.
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
rio RIO.List, base-prelude BasePrelude, ihaskell IHaskellPrelude, ghc-internal GHC.Internal.Data.List GHC.Internal.Data.OldList, rebase Rebase.Prelude
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. It is capable of list fusion, but it is restricted to its first list argument and its resulting list.
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
rio RIO.Vector
zipWith4 :: (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
rio RIO.Vector.Boxed
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
rio RIO.Vector.Storable, storablevector Data.StorableVector.Lazy Data.StorableVector.Lazy.Pattern
zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
rio RIO.Vector.Unboxed
zipWith4 :: Zip f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
non-empty Data.NonEmpty.Class
zipWith4 :: Zip4 f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
classy-prelude ClassyPrelude, chunked-data Data.ChunkedZip
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
storablevector Data.StorableVector
Like zipWith but for four input vectors If you need even more input vectors, you might write a function yourselve using unfoldrN and viewL.
zipWith4 :: (Size size, Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector size a -> Vector size b -> Vector size c -> Vector size d -> Vector size e
storablevector Data.StorableVector.Lazy.Typed
zipWith4 :: (Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) => (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-sized Data.Vector.Generic.Sized
zipWith4 :: (Prim a, Prim b, Prim c, Prim d, Prim e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
vector-sized Data.Vector.Primitive.Sized
zipWith4 :: (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
vector-sized Data.Vector.Sized
zipWith4 :: (Storable a, Storable b, Storable c, Storable d, Storable e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
vector-sized Data.Vector.Storable.Sized
zipWith4 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => (a -> b -> c -> d -> e) -> Vector n a -> Vector n b -> Vector n c -> Vector n d -> Vector n e
vector-sized Data.Vector.Unboxed.Sized
zipWith4 :: (Index ix, Source r1 e1, Source r2 e2, Source r3 e3, Source r4 e4) => (e1 -> e2 -> e3 -> e4 -> e) -> Array r1 ix e1 -> Array r2 ix e2 -> Array r3 ix e3 -> Array r4 ix e4 -> Array D ix e
massiv Data.Massiv.Array
Just like zipWith, except zip four arrays with a function.
zipWith4 :: (a -> b -> c -> d -> x) -> ListN n a -> ListN n b -> ListN n c -> ListN n d -> ListN n x
basement Basement.Sized.List
Zip 4 lists using a function
zipWith4 :: (a -> b -> c -> d -> e) -> Vec n a -> Vec n b -> Vec n c -> Vec n d -> Vec n e
clash-prelude Clash.Explicit.Prelude Clash.Explicit.Prelude.Safe Clash.Prelude Clash.Prelude.Safe Clash.Sized.Vector
zipWith4 :: (Zippable col, Sequential a, Sequential b, Sequential c, Sequential d) => (Element a -> Element b -> Element c -> Element d -> Element col) -> a -> b -> c -> d -> col
foundation Foundation.Collection
Like zipWith, but works with 4 collections.
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
prelude-compat Data.List2010
zipWith4 :: (a -> b -> c -> d -> e) -> T a -> T b -> T c -> T d -> T e
synthesizer-core Synthesizer.State.Signal
zipWith4 :: (Functor m, Applicative m, Monad m) => (a -> b -> c -> d -> e) -> Stream m a -> Stream m b -> Stream m c -> Stream m d -> Stream m e
leveldb-haskell Data.Stream.Monadic
zipWith4 :: (a -> b -> c -> d -> e) -> NESeq a -> NESeq b -> NESeq c -> NESeq d -> NESeq e
nonempty-containers Data.Sequence.NonEmpty
zipWith4 takes a function which combines four elements, as well as four sequences and returns a sequence of their point-wise combinations, analogous to zipWith.
zipWith4 :: (a -> b -> c -> d -> e) -> Infinite a -> Infinite b -> Infinite c -> Infinite d -> Infinite e
infinite-list Data.List.Infinite
Zip four infinite lists with a given function.
zipWith4 :: (Context a, Context b, Context c, Context d, Context e) => (a -> b -> c -> d -> e) -> Matrix a -> Matrix b -> Matrix c -> Matrix d -> Matrix e
matrices Data.Matrix