module List = struct ... end
Functions |
length
: 'a list -> int |
hd
: 'b list -> 'b |
Failure "hd"
if the list is empty.
tl
: 'c list -> 'c list |
Failure "tl"
if the list is empty.
nth
: 'd list -> int -> 'd |
Failure "nth"
if the list is too short.
rev
: 'e list -> 'e list |
append
: 'f list -> 'f list -> 'f list |
@
.
Not tail-recursive (length of the first argument). The @
operator is not tail-recursive either.
rev_append
: 'g list -> 'g list -> 'g list |
List.rev_append l1 l2
reverses l1
and catenates it to l2
.
This is equivalent to List.rev l1 @ l2
, but rev_append
is
tail-recursive and more efficient.
concat
: 'h list list -> 'h list |
flatten
: 'i list list -> 'i list |
iter
: f:('j -> unit) -> 'j list -> unit |
List.iter f [a1; ...; an]
applies function f
in turn to
a1; ...; an
. It is equivalent to
begin f a1; f a2; ...; f an; () end
.
map
: f:('k -> 'l) -> 'k list -> 'l list |
List.map f [a1; ...; an]
applies function f
to a1, ..., an
,
and builds the list [f a1; ...; f an]
with the results returned by f
. Not tail-recursive.
rev_map
: f:('m -> 'n) -> 'm list -> 'n list |
List.rev_map f l
gives the same result as
List.rev (List.map f l)
, but is tail-recursive and
more efficient.
fold_left
: f:('o -> 'p -> 'o) -> init:'o -> 'p list -> 'o |
List.fold_left f a [b1; ...; bn]
is
f (... (f (f a b1) b2) ...) bn
.
fold_right
: f:('q -> 'r -> 'r) -> 'q list -> init:'r -> 'r |
List.fold_right f [a1; ...; an] b
is
f a1 (f a2 (... (f an b) ...))
. Not tail-recursive.
iter2
: f:('s -> 't -> unit) -> 's list -> 't list -> unit |
List.iter2 f [a1; ...; an] [b1; ...; bn]
calls in turn
f a1 b1; ...; f an bn
.
Raise Invalid_argument
if the two lists have
different lengths.
map2
: f:('u -> 'v -> 'w) -> 'u list -> 'v list -> 'w list |
List.map2 f [a1; ...; an] [b1; ...; bn]
is
[f a1 b1; ...; f an bn]
.
Raise Invalid_argument
if the two lists have
different lengths. Not tail-recursive.
rev_map2
: f:('x -> 'y -> 'z) -> 'x list -> 'y list -> 'z list |
List.rev_map2 f l
gives the same result as
List.rev (List.map2 f l)
, but is tail-recursive and
more efficient.
fold_left2
: f:('a1 -> 'b1 -> 'c1 -> 'a1) -> init:'a1 -> 'b1 list -> 'c1 list -> 'a1 |
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]
is
f (... (f (f a b1 c1) b2 c2) ...) bn cn
.
Raise Invalid_argument
if the two lists have
different lengths.
fold_right2
: f:('d1 -> 'e1 -> 'f1 -> 'f1) -> 'd1 list -> 'e1 list -> init:'f1 -> 'f1 |
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c
is
f a1 b1 (f a2 b2 (... (f an bn c) ...))
.
Raise Invalid_argument
if the two lists have
different lengths. Not tail-recursive.
for_all
: f:('g1 -> bool) -> 'g1 list -> bool |
for_all p [a1; ...; an]
checks if all elements of the list
satisfy the predicate p
. That is, it returns
(p a1) && (p a2) && ... && (p an)
.
exists
: f:('h1 -> bool) -> 'h1 list -> bool |
exists p [a1; ...; an]
checks if at least one element of
the list satisfies the predicate p
. That is, it returns
(p a1) || (p a2) || ... || (p an)
.
for_all2
: f:('i1 -> 'j1 -> bool) -> 'i1 list -> 'j1 list -> bool |
exists2
: f:('k1 -> 'l1 -> bool) -> 'k1 list -> 'l1 list -> bool |
for_all
and exists
, but for a two-argument predicate.
Raise Invalid_argument
if the two lists have
different lengths.
mem
: 'm1 -> 'm1 list -> bool |
mem a l
is true if and only if a
is equal
to an element of l
.
memq
: 'n1 -> 'n1 list -> bool |
mem
, but uses physical equality instead of structural
equality to compare list elements.
find
: f:('o1 -> bool) -> 'o1 list -> 'o1 |
find p l
returns the first element of the list l
that satisfies the predicate p
.
Raise Not_found
if there is no value that satisfies p
in the
list l
.
filter
: f:('p1 -> bool) -> 'p1 list -> 'p1 list |
find_all
: f:('q1 -> bool) -> 'q1 list -> 'q1 list |
filter p l
returns all the elements of the list l
that satisfy the predicate p
. The order of the elements
in the input list is preserved. find_all
is another name
for filter
.
partition
: f:('r1 -> bool) -> 'r1 list -> 'r1 list * 'r1 list |
partition p l
returns a pair of lists (l1, l2)
, where
l1
is the list of all the elements of l
that
satisfy the predicate p
, and l2
is the list of all the
elements of l
that do not satisfy p
.
The order of the elements in the input list is preserved.
assoc
: 's1 -> ('s1 * 't1) list -> 't1 |
assoc a l
returns the value associated with key a
in the list of
pairs l
. That is,
assoc a [ ...; (a,b); ...] = b
if (a,b)
is the leftmost binding of a
in list l
.
Raise Not_found
if there is no value associated with a
in the
list l
.
assq
: 'u1 -> ('u1 * 'v1) list -> 'v1 |
assoc
, but uses physical equality instead of structural
equality to compare keys.
mem_assoc
: 'w1 -> ('w1 * 'x1) list -> bool |
assoc
, but simply return true if a binding exists,
and false if no bindings exist for the given key.
mem_assq
: 'y1 -> ('y1 * 'z1) list -> bool |
mem_assoc
, but uses physical equality instead of
structural equality to compare keys.
remove_assoc
: 'a2 -> ('a2 * 'b2) list -> ('a2 * 'b2) list |
remove_assoc a l
returns the list of
pairs l
without the first pair with key a
, if any.
Not tail-recursive.
remove_assq
: 'c2 -> ('c2 * 'd2) list -> ('c2 * 'd2) list |
remove_assq
, but uses physical equality instead
of structural equality to compare keys. Not tail-recursive.
split
: ('e2 * 'f2) list -> 'e2 list * 'f2 list |
split [(a1,b1); ...; (an,bn)]
is ([a1; ...; an], [b1; ...; bn])
.
Not tail-recursive.
combine
: 'g2 list -> 'h2 list -> ('g2 * 'h2) list |
combine ([a1; ...; an], [b1; ...; bn])
is
[(a1,b1); ...; (an,bn)]
.
Raise Invalid_argument
if the two lists
have different lengths. Not tail-recursive.
sort
: cmp:('i2 -> 'i2 -> int) -> 'i2 list -> 'i2 list |
compare
function is a suitable comparison function.
The resulting list is sorted in increasing order.
List.sort
is guaranteed to run in constant heap space
(in addition to the size of the result list) and logarithmic
stack space.List.stable_sort
.
stable_sort
: cmp:('j2 -> 'j2 -> int) -> 'j2 list -> 'j2 list |
List.sort
, but the sorting algorithm is stable.