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]

   ihaskell	IHaskellPrelude

   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]

   incipit-base	Incipit.Base

   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]

   dimensional	Numeric.Units.Dimensional.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"]
   

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

   distribution-opensuse	OpenSuse.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. zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

   faktory	Faktory.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"]
   

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

   hledger-web	Hledger.Web.Import

   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"]
   

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

   constrained-categories	Control.Category.Constrained.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"]
   

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

   constrained-categories	Control.Category.Hask

   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]

   copilot-language	Copilot.Language.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]

    listsafe	Data.List.Safe

    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"]
    

Page 4 of many | Previous | Next