The OCaml standard library provides a module for list functions. This BatList module can be used to extend the List module or as a standalone module. It provides new functions and modify the behavior of some other ones (in particular all functions are now tail-recursive).
The following functions have the same behavior as the List module ones but are tail-recursive: map, append, concat, flatten, fold_right, remove_assoc, remove_assq, split. That means they will not cause a Stack_overflow when used on very long list.
The implementation might be a little more slow in bytecode, but compiling in native code will not affect performances.
This module extends Stdlib's List module, go there for documentation on the rest of the functions and types.
if the list is empty. This function takes linear time.
val length : 'a list-> int
Return the length (number of elements) of the given list.
val compare_lengths : 'a list->'b list-> int
Compare the lengths of two lists. compare_lengths l1 l2 is equivalent to compare (length l1) (length l2), except that the computation stops after itering on the shortest list.
since 2.7.0
val compare_length_with : 'a list->int -> int
Compare the length of a list to an integer. compare_length_with l n is equivalent to compare (length l) n, except that the computation stops after at most n iterations on the list.
shuffle ~state:rs l randomly shuffles the elements of l. The optional random state rs allows to control the random numbers being used during shuffling (for reproducibility).
Shuffling is implemented using the Fisher-Yates algorithm on an array and works in O(n), where n is the number of elements of l.
since 2.6.0
val append : 'a list->'a list->'a list
append l1 l2 is a concatenation of l1 and l2. Same function as the infix operator @. Tail-recursive. This function takes O(length l1) time.
val rev_append : 'a list->'a list->'a list
List.rev_append l1 l2 reverses l1 and concatenates it to l2.
val concat : 'a list list->'a list
Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Tail-recursive.
val flatten : 'a list list->'a list
Same as concat.
val singleton : 'a->'a list
Create a list consisting of exactly one element.
since 2.1
Constructors
val make : int ->'a->'a list
Similar to String.make, make n x returns a list containing n elements x.
val range : int ->[< `To | `Downto ]->int ->int list
range 1 `To 3 = [1; 2; 3]. range 3 `Downto 1 = [3; 2; 1].
val frange : float ->[< `To | `Downto ]->float ->int ->float list
frange start `To stop n generates (without accumulating floating point errors) n floats in the range [start..stop]. n must be >= 2. At each step, floats in an increasing (resp. decreasing) range increase (resp. decrease) by approximately (stop - start) / (n - 1).
unfold init f creates a list by repeatedly applying f to the second element of its own result, starting from the initial value init. The first element of each result is accumulated in a list. The list is terminated and returned as soon as f returns None.
Example: List.unfold 0 (fun x -> if x = 3 then None else Some (string_of_int x, x+1)) will return ["0";"1";"2"]
since 2.1
val unfold_exn : (unit ->'a)->'a list * exn
Creates a list containing the results of sequential calls to f(). f() is called repeatedly until it throws an exception. Both the results list, as well as the exception thrown are returned in a (results_list, exn) pair. Warning: if calls to f() never throw an exception, unfold_exn is an infinite loop.
val equal : ('a->'a-> bool)->'a list->'a list-> bool
equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.
Note: the eq function may be called even if the lists have different length. If you know your equality function is costly, you may want to check compare_lengths first.
since 3.3.0 and 4.12.0
Iterators
val iter : ('a-> unit)->'a list-> unit
List.iter f [a0; a1; ...; an] applies function f in turn to a0; a1; ...; an. It is equivalent to begin f a0; f a1; ...; f an; () end.
val iteri : (int ->'a-> unit)->'a list-> unit
iteri f l will call (f 0 a0); (f 1 a1) ... (f n an) where a0..an are the elements of the list l.
val map : ('a->'b)->'a list->'b list
map f [a0; a1; ...; an] applies function f to a0, a1, ..., an, and builds the list [f a0; f a1; ...; f an] with the results returned by f. Tail-recursive.
val rev_map : ('a->'b)->'a list->'b list
List.rev_map f l gives the same result as List.rev (List.map f l).
val mapi : (int ->'a->'b)->'a list->'b list
mapi f l will build the list containing (f 0 a0); (f 1 a1) ... (f n an) where a0..an are the elements of the list l.
val fold_left : ('a->'b->'a)->'a->'b list->'a
List.fold_left f a [b0; b1; ...; bn] is f (... (f (f a b0) b1) ...) bn.
val fold : ('a->'b->'a)->'a->'b list->'a
Alias for fold_left.
val fold_lefti : ('a->int ->'b->'a)->'a->'b list->'a
As fold_left, but with the index of the element, from 0 to length li - 1, as additional argument.
since 2.3.0
val fold_right : ('a->'b->'b)->'a list->'b->'b
List.fold_right f [a0; a1; ...; an] b is f a0 (f a1 (... (f an b) ...)). Tail-recursive.
val fold_righti : (int ->'b->'a->'a)->'b list->'a->'a
As fold_right, but with the index of the element, from 0 to length li - 1, as additional argument.
val fold_left_map : ('a->'b->'a * 'c)->'a->'b list->'a * 'c list
Combines fold_left and map. Tail-recursive.
More precisely :
fold_left_map f acc [] = (acc, [])
fold_left_map f acc (x :: xs) =
let (acc', y) = f acc x in
let (res, ys) = fold_left_map acc' xs in
(res, y :: ys)
since 2.6.0
val max : ?cmp:('a->'a-> int)->'a list->'a
max l returns the largest value in l as judged by Pervasives.compare (by default). You can provide another comparison function via the optional cmp parameter.
min l returns the smallest value in l as judged by Pervasives.compare (by default). You can provide another comparison function via the optional cmp parameter.
kahan_sum l returns a numerically-accurate sum of the floats of l. See BatArray.fsum for more details.
since 2.2.0
val min_max : ?cmp:('a->'a-> int)->'a list->'a * 'a
min_max l returns the pair (smallest, largest) from l as judged by Pervasives.compare (by default). You can provide another comparison function via the optional cmp parameter.
if two lists have different lengths. Tail-recursive.
List scanning
val mem : 'a->'a list-> bool
mem a l is true if and only if a is equal to an element of l.
val mem_cmp : ('a->'a-> int)->'a->'a list-> bool
Same as List.mem, but the comparator function is explicitly provided.
since 2.2.0
val memq : 'a->'a list-> bool
Same as List.mem, but uses physical equality instead of structural equality to compare list elements.
Unary predicate, One list
val for_all : ('a-> bool)->'a list-> bool
for_all p [a0; a1; ...; an] checks if all elements of the list satisfy the predicate p. That is, it returns (p a0) && (p a1) && ... && (p an).
val exists : ('a-> bool)->'a list-> bool
exists p [a0; a1; ...; an] checks if at least one element of the list satisfies the predicate p. That is, it returns (p a0) || (p a1) || ... || (p an).
Binary predicate, Two lists
val for_all2 : ('a->'b-> bool)->'a list->'b list-> bool
Same as List.for_all, but for a two-argument predicate.
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.
val count_matching : ('a-> bool)->'a list-> int
count_matching p l returns the number of elements in l that satisfy p. Semantically equivalent but faster than length (filter p l).
val filteri : (int ->'a-> bool)->'a list->'a list
filteri p [a0; a1; ...; an] returns all the elements ai of index i that satisfy the predicate p i ai. The order of the elements in the input list is preserved.
since 2.2.0
val filter_map : ('a->'b option)->'a list->'b list
filter_map f l calls (f a0) (f a1).... (f an) where a0,a1..an are the elements of l. It returns the list of elements bi such as f ai = Some bi (when f returns None, the corresponding element of l is discarded).
val filteri_map : (int ->'a->'b option)->'a list->'b list
filteri_map f l calls (f 0 a0) (f 1 a1).... (f n an) where a0,a1..an are the elements of l. It returns the list of elements bi such as f ai = Some bi (when f returns None, the corresponding element of l is discarded).
val partition : ('a-> bool)->'a list->'a list * 'a 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.
val partition_map :
('a->('b, 'c)BatEither.t)->'a list->'b list * 'c list
partition_map f l returns a pair of lists (l1, l2) such that, for each element x of the input list l:
if f x is Left y1, then y1 is in l1, and
if f x is Right y2, then y2 is in l2. The output elements are included in l1 and l2 in the same relative order as the corresponding input elements in l. In particular, partition_map (fun x -> if f x then Left x else Right x) l is equivalent to partition f l.
since 3.3.0
val index_of : 'a->'a list->int option
index_of e l returns the index of the first occurrence of e in l, or None if there is no occurrence of e in l
val index_ofq : 'a->'a list->int option
index_ofq e l behaves as index_of e l except it uses physical equality
val rindex_of : 'a->'a list->int option
rindex_of e l returns the index of the last occurrence of e in l, or None if there is no occurrence of e in l
val rindex_ofq : 'a->'a list->int option
rindex_ofq e l behaves as rindex_of e l except it uses physical equality
val unique : ?eq:('a->'a-> bool)->'a list->'a list
unique cmp l returns the list l without any duplicate element. The default comparator ( = ) is used if no comparison function specified.
Implementation Note: The current implementation removes any elements where the tail of the list contains an equal element, thus it keeps the *last* copy of each equal element.
This function takes O(n^2) time.
seesort_unique
to save time in cases when reordering the list is acceptable
since 2.0
val unique_cmp : ?cmp:('a->'a-> int)->'a list->'a list
As unique, except comparator parameter returns an int. Default comparator is Pervasives.compare. This function takes O(n log n) time.
Implementation Note: The current implementation removes subsequent elements that compare as equal to earlier elements in the list, thus it keeps the *first* copy of each equal element.
since 1.3.0
val unique_hash :
?hash:('a-> int)->?eq:('a->'a-> bool)->'a list->'a list
As unique, except uses a hash table to cut down the expected runtime to linear, assuming a good hash function. ?hash defaults to Hashtbl.hash and ?eq defaults to (=).
Implementation Note: The current implementation removes subsequent elements that hash and compare as equal to earlier elements in the list, thus it keeps the *first* copy of each equal element.
since 2.0.0
Association lists
val assoc : 'a->('a * 'b) list->'b
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.
if there is no value associated with a in the list l.
val assoc_opt : 'a->('a * 'b) list->'b option
assoc_opt a l returns the value associated with key a in the list of pairs l. That is, assoc_opt a [ ...; (a,b); ...] = b if (a,b) is the leftmost binding of a in list l. Returns None if there is no value associated with a in the list l.
since 2.7.0
val assoc_inv : 'b->('a * 'b) list->'a
assoc_inv b l returns the key associated with value b in the list of pairs l. That is, assoc b [ ...; (a,b); ...] = a if (a,b) is the leftmost binding of a in list l.
if n <= 0. Each list in the result has size n, except the last one which may have fewer elements in case l was too short. Example: ntake 2 [1; 2; 3; 4; 5] = [[1; 2]; [3; 4]; [5]]
since 2.2.0
val drop : int ->'a list->'a list
drop n l returns l without the first n elements, or the empty list if l have less than n elements.
val takedrop : int ->'a list->'a list * 'a list
takedrop n l is equivalent to (take n l, drop n l) but is done in one pass.
since 2.2.0
val take_while : ('a-> bool)->'a list->'a list
take_while p xs returns the (possibly empty) longest prefix of elements of xs that satisfy the predicate p.
val drop_while : ('a-> bool)->'a list->'a list
drop_while p xs returns the suffix remaining after take_while p xs.
val span : ('a-> bool)->'a list->'a list * 'a list
span, applied to a predicate p and a list xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the list. This is equivalent to (take_while p xs, drop_while p xs), but is done in one pass.
since 2.1
val fold_while :
('acc->'a-> bool)->('acc->'a->'acc)->'acc->'a list->'acc * 'a list
fold_while p f init l, accumulates elements x of list l using function f, as long as predicate p acc x holds. At the end, the accumulated value along with the remaining part of the list are returned.
since 2.10.0
val nsplit : ('a-> bool)->'a list->'a list list
nsplit, applied to a predicate p and a list xs, returns a list of lists. xs is split when p x is true and x is excluded from the result.
If elements that satisfy p are consecutive, or at the beginning or end of the input list, the output list will contain empty lists marking their position. For example, split (fun n -> n<0) [-1;2;-2;-3;4;-5] is [[];[2];[];[4];[]]. This is consistent with the behavior of String.nsplit, where String.nsplit ";" "1;2;;3;" = ["1";"2";"";"3";""].
Note that for any xss : 'a list list and sep : 'a, we always have that flatten (interleave [sep] (nsplit ((=) sep) xss)) is xss.
since 2.1
val group_consecutive : ('a->'a-> bool)->'a list->'a list list
The group_consecutive function takes a list and returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements. For example, group_consecutive (=) [3;3;4;3;3] = [[3;3];[4];[3;3]].
Note: In the next major version, this function is intended to replace the current group, which also sorts its input before grouping, and which will therefore be renamed into something more pertinent, such as classify, regroup, or group_sort.
since 2.1
val interleave : ?first:'a->?last:'a->'a->'a list->'a list
Returns an enumeration of the elements of a list. This enumeration may be used to visit elements of the list in forward order (i.e. from the first element to the last one).
Returns an enumeration of the elements of a list. This enumeration may be used to visit elements of the list in backwards order (i.e. from the last element to the first one).
Build a list from an enumeration. The first element of the enumeration becomes the last element of the list, the second element of the enumeration becomes the second-to-last element of the list...
List of pairs
val split : ('a * 'b) list->'a list * 'b list
Transform a list of pairs into a pair of lists: split [(a0,b0); (a1,b1); ...; (an,bn)] is ([a0; a1; ...; an], [b0;
b1; ...; bn]). Tail-recursive.
val combine : 'a list->'b list->('a * 'b) list
Transform a pair of lists into a list of pairs: combine [a0; a1; ...; an] [b0; b1; ...; bn] is [(a0,b0); (a1,b1); ...; (an,bn)].
if two lists have different lengths. Tail-recursive.
Sorting
val sort : ('a->'a-> int)->'a list->'a list
Sort a list in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see Array.sort for a complete specification). For example, Pervasives.compare 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.
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val stable_sort : ('a->'a-> int)->'a list->'a list
Same as List.sort, but the sorting algorithm is guaranteed to be stable (i.e. elements that compare equal are kept in their original order) .
The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.
val merge : ('a->'a-> int)->'a list->'a list->'a list
Merge two lists: Assuming that l1 and l2 are sorted according to the comparison function cmp, merge cmp l1 l2 will return a sorted list containing all the elements of l1 and l2. If several elements compare equal, the elements of l1 will be before the elements of l2. Not tail-recursive (sum of the lengths of the arguments).
val sort_uniq : ('a->'a-> int)->'a list->'a list
sort_uniq cmp l returns the list l sorted and without any duplicate element. cmp is a usual comparison function providing total order.
This function takes O(n log n) time.
since 2.3.0
val sort_unique : ('a->'a-> int)->'a list->'a list
synonym for sort_uniq
Utilities
val group : ('a->'a-> int)->'a list->'a list list
group cmp l returns list of groups and each group consists of elements judged equal by comparison function cmp. Groups in the resulting list appear in order given by cmp. All groups are always nonempty. group returns [] only if l is empty.
For example group cmp [f;c;b;e;d;a] can give [[a;b];[c];[d;e;f]] if following conditions are met: cmp a b = 0, cmp b c = -1, cmp c d = -1, cmp d e = 0, ...
See the note on group_consecutive.
val cartesian_product : 'a list->'b list->('a * 'b) list
Different from List.combine, this returns every pair of elements formed out of the two lists. cartesian_product [a0; a1; ...; an] [b0; b1; ...; bn] =
[(a0,b0);(a0,b1); ...; (a0,bn); (a1,b0); ..; (a1, bn);
...; (an,bn)]. The lists can be of unequal size.
val n_cartesian_product : 'a list list->'a list list
Given n lists, return the n-way cartesian product of these lists. Given [a;b];[c];[d;e;f], returns [a;c;d];[a;c;e];[a;c;f];[b;c;d];[b;c;e];[b;c;f], all ways of choosing one element from each input list.
val transpose : 'a list list->'a list list
Transposes a list of lists, turning rows of the input into columns of the output and vice versa.
Return the n-th element of the given list. The first element (head of the list) is at position 0. Return None if the list is too short. Raise Invalid_argument "List.nth" if n is negative.
The following modules replace functions defined in List with functions behaving slightly differently but having the same name. This is by design: the functions are meant to override the corresponding functions of List.