:: [c] -> [b] -> [(c, b)]

zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1,'a'),(2,'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1,'a')]

>>> zip [1, 2] ['a']
[(1,'a')]

>>> zip [] [1..]
[]

>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] undefined
[]

>>> zip undefined []
*** Exception: Prelude.undefined
...

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

zipExact xs ys =
| length xs == length ys = zip xs ys
| otherwise              = error "some message"

zip takes two lists and returns a list of corresponding pairs.

zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]

If one input list is short, excess elements of the longer list are discarded:

zip [1] ['a', 'b'] = [(1, 'a')]
zip [1, 2] ['a'] = [(1, 'a')]

zip is right-lazy:

zip [] _|_ = []
zip _|_ [] = _|_

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

cartesianProduct (,)

zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1, 'a'), (2, 'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1, 'a')]

>>> zip [1, 2] ['a']
[(1, 'a')]

>>> zip [] [1..]
[]

>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] _|_
[]

>>> zip _|_ []
_|_

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

Generalized version of concurrently.

Generalized version of concurrently.

Default '>*< implementation for non-invertible Applicatives.

O(min(m,n)) Zip two vectors.

Pair two samples. It's like zip but requires that both samples have equal size.

O(min(m,n)) Zip two vectors

Construct a mesh graph from two lists of vertices. Complexity: O(L1 * L2) time, memory and size, where L1 and L2 are the lengths of the given lists.

mesh xs     []   == empty
mesh []     ys   == empty
mesh [x]    [y]  == vertex (x, y)
mesh xs     ys   == box (path xs) (path ys)
mesh [1..3] "ab" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(2,'b')), ((2,'a'),(2,'b'))
, ((2,'a'),(3,'a')), ((2,'b'),(3,'b')), ((3,'a'),(3,'b')) ]

Construct a torus graph from two lists of vertices. Complexity: O(L1 * L2) time, memory and size, where L1 and L2 are the lengths of the given lists.

torus xs    []   == empty
torus []    ys   == empty
torus [x]   [y]  == edge (x,y) (x,y)
torus xs    ys   == box (circuit xs) (circuit ys)
torus [1,2] "ab" == edges [ ((1,'a'),(1,'b')), ((1,'a'),(2,'a')), ((1,'b'),(1,'a')), ((1,'b'),(2,'b'))
, ((2,'a'),(1,'a')), ((2,'a'),(2,'b')), ((2,'b'),(1,'b')), ((2,'b'),(2,'a')) ]

Decides if two structures match exactly. If they match, return zipped version of them.

zipMatch ta tb = Just tab

holds if and only if both of

ta = fmap fst tab
tb = fmap snd tab

holds. Otherwise, zipMatch ta tb = Nothing. For example, the type signature of zipMatch on the list Functor [] reads as follows:

zipMatch :: [a] -> [b] -> Maybe [(a,b)]

zipMatch as bs returns Just (zip as bs) if the lengths of two given lists are same, and returns Nothing otherwise.

Example

>>> zipMatch [1, 2, 3] ['a', 'b', 'c']
Just [(1,'a'),(2,'b'),(3,'c')]

>>> zipMatch [1, 2, 3] ['a', 'b']
Nothing