The Standard ML Basis Library

The ListPair structure

The ListPair structure provides operations on pairs of lists. These operations do not require that the lists have the same length; when the lists are of uneven lengths, the excess elements from the tail of the longer list are ignored.

Synopsis

signature LIST_PAIR
structure ListPair : LIST_PAIR


Interface

val zip : ('a list * 'b list) -> ('a * 'b) list
val unzip : ('a * 'b) list -> ('a list * 'b list)
val map : ('a * 'b -> 'c) -> ('a list * 'b list) -> 'c list
val app : ('a * 'b -> unit) -> ('a list * 'b list) -> unit
val foldl : (('a * 'b * 'c) -> 'c) -> 'c -> ('a list * 'b list) -> 'c
val foldr : (('a * 'b * 'c) -> 'c) -> 'c -> ('a list * 'b list) -> 'c
val all : ('a * 'b -> bool) -> ('a list * 'b list) -> bool
val exists : ('a * 'b -> bool) -> ('a list * 'b list) -> bool


Description

zip (l1, l2)

combines the two lists l1 and l2 into a list of pairs, with the first element of each list comprising the first element of the result, the second elements comprising the second element of the result, and so on. If the lists are of unequal lengths, the excess elements from the tail of the longer one are ignored.

unzip l

returns a pair of lists formed by splitting the elements of l. This is the inverse of zip for equal length lists.

map f (l1, l2)

maps the function f over the list of pairs of elements from the lists l1 and l2, returning the list of results. If the lists are of unequal lengths, the excess elements from the tail of the longer one are ignored. The above expression is equivalent to: List.map f (zip (l1, l2)).

app f (l1, l2)

applies the function f to the list of pairs of elements from from the lists l1 and l2. If the lists are of unequal lengths, the excess elements from the tail of the longer one are ignored. The above expression is equivalent to: List.app f (zip (l1, l2)).

foldl f c (l1, l2)

foldr f c (l1, l2)

return the result of folding the function f over the pair of lists l1 and l2. They are respectively equivalent to: List.foldl f' c (zip (l1, l2)) and List.foldr f' c (zip (l1, l2)) where f' is fn ((a,b),c) => f(a,b,c).

all pred (l1, l2)

exists pred (l1, l2)

These functions provide short-circuit testing of a predicate over a pair of lists. They are respectively equivalent to: List.all pred (zip (l1, l2)) and List.exists pred (zip (l1, l2)).

Discussion

Rationale:

Another approach to these functions is to raise an exception when the argument lists are of uneven length. We chose not to do this, because comparing the lists for length conflicts with the short-circuit evaluation of all and exists.

See Also

List

Last Modified April 8, 1996
Copyright © 1996 AT&T