include module type of struct include List endCompare 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.
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.
Return the n-th element of the given list. The first element (head of the list) is at position 0.
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.
List.rev_append l1 l2 reverses l1 and concatenates it to l2. This is equivalent to List.rev l1 @ l2, but rev_append is tail-recursive and more efficient.
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.
Same as List.iter, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f
List.fold_left f a [b1; ...; bn] is f (... (f (f a b1) b2) ...) bn.
List.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.
List.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.
List.fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)).
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) for a non-empty list and true if the list is empty.
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 a non-empty list and false if the list is empty.
Same as List.for_all, but for a two-argument predicate.
Same as List.exists, but for a two-argument predicate.
Same as List.mem, but uses physical equality instead of structural equality to compare list elements.
find p l returns the first element of the list l that satisfies the predicate p.
find_map f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.
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 List.filter.
Same as List.filter, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
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 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.
Same as List.assoc, but uses physical equality instead of structural equality to compare keys.
Same as List.assoc_opt, but uses physical equality instead of structural equality to compare keys.
Same as List.assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.
Same as List.mem_assoc, but uses physical equality instead of structural equality to compare keys.
Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].
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, Stdlib.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.
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.
Same as List.sort or List.stable_sort, whichever is faster on typical input.
Same as List.sort, but also remove duplicates.
val to_seq : 'a list -> 'a Seq.tIterate on the list
val of_seq : 'a Seq.t -> 'a listCreate a list from the iterator
include module type of struct include Xlist endval empty : 'a tempty = []
val singleton : 'a -> 'a tsingleton x = [x]
val make : int -> 'a -> 'a tmake n x returns a list of length n filled with x. Throws Invalid_argument "List.make" when n < 0.
val init : int -> (int -> 'a) -> 'a tinit n f returns a list of [f 0; f 1; ..; f (n-1)]. Throws Invalid_argument "List.init" when n < 0.
val to_list : 'a t -> 'a listval to_array : 'a t -> 'a arrayval of_list : 'a list -> 'a tval of_array : 'a array -> 'a tval fold_right : ('a -> 'st -> 'st) -> 'a t -> 'st -> 'stList must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".
List must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".
concat_map f xs = concat @@ map f xs but much faster.
concat_map f xs = rev @@ concat @@ map f xs but much faster.
val map_accum_left :
('acc -> 'a -> 'acc * 'b) ->
'acc ->
'a t ->
'acc * 'b listmapAccumL f acc t behaves like a combination of map and fold_left; it applies a function f to each element of a list t, passing an accumulating parameter acc from left to right, and returning a final value of this accumulator together with the new list.
The last element of the list. Raises Failure when the argument is . last [1;2;3] = 3
sub_default t pos len returns a sublist of t from the position pos (0-start) and length len.
The region specified by pos and len is trimmed by t: if it exceeds the size of t, it is intersected with the region from 0 and length List.length t. One tricky example is:
sub_default [0;1;2;3;4;5] (-1) 3 = [0;1]
span p xs extract the longest prefix of xs whose elements satisfy p.
Filter out duplicate elements using the given equality. The first result list is the list of first unique occurrences, the second result list is the rest, the duplications removed from the first result list, paired with the corresponding element of the first result list.
O(n^2).
Same as uniq_dup but only works for already sorted by the same ordering. O(n log n)
Check the list is a unique list or not, wrt the equality function. If not, it returns a dupe example.
has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (4,5)] = None has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )
O(n^2)
group xs 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:
group ['M'; 'i'; 's'; 's'; 'i'; 's'; 's'; 'i'; 'p'; 'p'; 'i'] = [['M'],['i'],['s';'s'];['i'];['s';'s'];['i'];['p';'p'];['i']]
Haskell's group.
Same as group but equality can be given. Haskell's groupBy
Haskell's zip. Like List.combine but does not raise when the lengths are not equal. Tail recursive.
val accum : 'a list ref -> 'a -> unitaccum xsref x is equivalent with xsref := x :: !xsref
val (+::=) : 'a list ref -> 'a -> unitSame as accum
module Infix = Xlist.Infixmodule Stdlib = Xlist.StdlibThese non tail recursive versions are from stdlib.
Check the list is a unique list or not, wrt the key function. If not, it returns a dupe example.
is_unique fst [(1,2); (2,3); (4,5)] = None is_unique fst [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )