Hoogle Search

Within LTS Haskell 24.25 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   base	Prelude

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

2. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   base	Data.List

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

3. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   base	GHC.List

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

4. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   hedgehog	Hedgehog.Internal.Prelude

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

5. zipWithExact :: Partial => (a -> b -> c) -> [a] -> [b] -> [c]

   safe	Safe.Exact

   zipWithExact f xs ys =
   | length xs == length ys = zipWith f xs ys
   | otherwise              = error "some message"
   

6. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   ghc	GHC.Prelude.Basic

   No documentation available.

7. strictZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   ghc	GHC.Utils.Misc

   No documentation available.

8. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   rio	RIO.List

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

9. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   rio	RIO.Prelude

   zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function.

   zipWith (,) xs ys == zip xs ys
   zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
   

   zipWith is right-lazy:

   >>> let f = undefined
   
   >>> zipWith f [] undefined
   []
   

   zipWith is capable of list fusion, but it is restricted to its first list argument and its resulting list.

   Examples

   zipWith (+) can be applied to two lists to produce the list of corresponding sums:

   >>> zipWith (+) [1, 2, 3] [4, 5, 6]
   [5,7,9]
   

   >>> zipWith (++) ["hello ", "foo"] ["world!", "bar"]
   ["hello world!","foobar"]
   

10. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

    Cabal-syntax	Distribution.Compat.Prelude

    No documentation available.

Page 1 of many | Next