module List: BatListtype'at ='a list
include BatEnum.Enumerable
include BatInterfaces.Mappable
val is_empty : 'a list -> boolis_empty e returns true if e does not contains any element.val cons : 'a -> 'a list -> 'a listcons h t returns the list starting with h and continuing as tval first : 'a list -> 'aEmpty_list if
the list is empty (similar to hd).val hd : 'a list -> 'afirst, butFailure if the list is empty.val tl : 'a list -> 'a listFailure if the list is empty.val last : 'a list -> 'aEmpty_list if
the list is empty. This function takes linear time.val length : 'a list -> intval at : 'a list -> int -> 'aat l n returns the n-th element of the list l orInvalid_argument if the index is outside of l bounds. O(l)val rev : 'a list -> 'a listval append : 'a list -> 'a list -> 'a list@.
Tail-recursive O(length of the first argument).val rev_append : 'a list -> 'a list -> 'a listList.rev_append l1 l2 reverses l1 and concatenates it to l2.val concat : 'a list list -> 'a listval flatten : 'a list list -> 'a listconcat.val singleton : 'a -> 'a listval make : int -> 'a -> 'a listString.make, make n x returns a
list containing n elements x.val range : int -> [< `Downto | `To ] -> int -> int listrange 1 `To 3 = [1; 2; 3].
range 3 `Downto 1 = [3; 2; 1].Invalid_argument in (range i `To j) if (i > j).Invalid_argument in (range i `Downto j) if (i < j).val init : int -> (int -> 'a) -> 'a listArray.init, init n f returns the list containing
the results of (f 0),(f 1).... (f (n-1)).Invalid_argument if n < 0.val unfold : 'b -> ('b -> ('a * 'b) option) -> 'a listunfold 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_exc : (unit -> 'a) -> 'a list * exnf(). 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_exc
is an infinite loop.val iter : ('a -> unit) -> 'a list -> unitList.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 -> unititeri 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 listmap 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 listList.rev_map f l gives the same result as
List.rev (List.map f l).val mapi : (int -> 'a -> 'b) -> 'a list -> 'b listmapi 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 -> 'aList.fold_left f a [b0; b1; ...; bn] is
f (... (f (f a b0) b1) ...) bn.val fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b list -> 'afold_left, but with the index of the element, from 0 to
length li - 1, as additional argument.val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'bList.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 -> 'afold_right, but with the index of the element, from 0 to
length li - 1, as additional argument.val reduce : ('a -> 'a -> 'a) -> 'a list -> 'aList.reduce f h::t is fold_left f h t.Invalid_argument on empty list.val max : 'a list -> 'amax l returns the largest value in l as judged by
Pervasives.compareval min : 'a list -> 'amin l returns the smallest value in l as judged by
Pervasives.compareval sum : int list -> intsum l returns the sum of the integers of lInvalid_argument on the empty list.val fsum : float list -> floatfsum l returns the sum of the floats of lInvalid_argument on the empty list.val kahan_sum : float list -> floatkahan_sum l returns a numerically-accurate sum of the floats of
l. See BatArray.fsum for more details.val min_max : ?cmp:('a -> 'a -> int) -> 'a list -> 'a * 'amin_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.Invalid_argument on an empty list.val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unitList.iter2 f [a0; a1; ...; an] [b0; b1; ...; bn] calls in turn
f a0 b0; f a1 b1; ...; f an bn.Different_list_size if the two lists have
different lengths.val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listList.map2 f [a0; a1; ...; an] [b0; b1; ...; bn] is
[f a0 b0; f a1 b1; ...; f an bn].Different_list_size if the two lists have
different lengths. Tail-recursive.val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c listList.rev_map2 f l1 l2 gives the same result as
List.rev (List.map2 f l1 l2), but is tail-recursive and
more efficient.val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'aList.fold_left2 f a [b0; b1; ...; bn] [c0; c1; ...; cn] is
f (... (f (f a b0 c0) b1 c1) ...) bn cn.Different_list_size if the two lists have
different lengths.val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'cList.fold_right2 f [a0; a1; ...; an] [b0; b1; ...; bn] c is
f a0 b0 (f a1 b1 (... (f an bn c) ...)).Different_list_size if the two lists have
different lengths. Tail-recursive.val mem : 'a -> 'a list -> boolmem 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 -> boolList.mem, but the comparator function is explicitely
provided.val memq : 'a -> 'a list -> boolList.mem, but uses physical equality instead of structural
equality to compare list elements.val for_all : ('a -> bool) -> 'a list -> boolfor_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 -> boolexists 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).val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> boolList.for_all, but for a two-argument predicate.Invalid_argument if the two lists have
different lengths.val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> boolList.exists, but for a two-argument predicate.Invalid_argument if the two lists have
different lengths.val subset : ('a -> 'b -> int) -> 'a list -> 'b list -> boolsubset cmp l l' check if all elements of the list l
is contained in the list l' by applying cmp as comparator.val find : ('a -> bool) -> 'a list -> 'afind p l returns the first element of the list l
that satisfies the predicate p.Not_found if there is no value that satisfies p in the
list l.val find_exn : ('a -> bool) -> exn -> 'a list -> 'afind_exn p e l returns the first element of l such as p x
returns true or raises e if such an element has not been found.val findi : (int -> 'a -> bool) -> 'a list -> int * 'afindi p e l returns the first element ai of l along with its
index i such that p i ai is true, orNot_found if no
such element has been found.val find_map : ('a -> 'b option) -> 'a list -> 'bfind_map pred list finds the first element of list for which
pred element returns Some r. It returns r immediately
once found orNot_found if no element matches the
predicate. See also BatList.filter_map.val rfind : ('a -> bool) -> 'a list -> 'arfind p l returns the last element x of l such as p x returns
true orNot_found if such element as not been found.val filter : ('a -> bool) -> 'a list -> 'a listfilter 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 filteri : (int -> 'a -> bool) -> 'a list -> 'a listfilter 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.val filter_map : ('a -> 'b option) -> 'a list -> 'b listfilter_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 listfilter_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 find_all : ('a -> bool) -> 'a list -> 'a listfind_all is another name for List.filter.val partition : ('a -> bool) -> 'a list -> 'a list * 'a listpartition 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 index_of : 'a -> 'a list -> int optionindex_of e l returns the index of the first occurrence of e
in l, or None if there is no occurrence of e in lval index_ofq : 'a -> 'a list -> int optionindex_ofq e l behaves as index_of e l except it uses
physical equalityval rindex_of : 'a -> 'a list -> int optionrindex_of e l returns the index of the last occurrence of e
in l, or None if there is no occurrence of e in lval rindex_ofq : 'a -> 'a list -> int optionrindex_ofq e l behaves as rindex_of e l except it uses
physical equalityval unique : ?eq:('a -> 'a -> bool) -> 'a list -> 'a listunique 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.
Since 2.0
See also sort_unique to save time in cases when reordering the list is
acceptable
val unique_cmp : ?cmp:('a -> 'a -> int) -> 'a list -> 'a listunique, 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 listunique, 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
val assoc : 'a -> ('a * 'b) list -> 'bassoc 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.Not_found if there is no value associated with a in the
list l.val assoc_inv : 'b -> ('a * 'b) list -> 'aassoc_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.Not_found if there is no key associated with b in the
list l.val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) listremove_assoc a l returns the list of
pairs l without the first pair with key a, if any.
Tail-recursive.val mem_assoc : 'a -> ('a * 'b) list -> boolList.assoc, but simply return true if a binding exists,
and false if no bindings exist for the given key.val assq : 'a -> ('a * 'b) list -> 'bList.assoc, but uses physical equality instead of structural
equality to compare keys.val assq_inv : 'b -> ('a * 'b) list -> 'aList.assoc_inv, but uses physical equality instead of structural
equality to compare keys.val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) listList.remove_assoc, but uses physical equality instead
of structural equality to compare keys. Tail-recursive.val mem_assq : 'a -> ('a * 'b) list -> boolList.mem_assoc, but uses physical equality instead of
structural equality to compare keys.val modify : 'a -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) listmodify a f l returns the same list as l but with value associated
to key a replaced with f a.Not_found if no value is associated with a in lval modify_def : 'b -> 'a -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) listmodify_def dfl a f l performs as modify a f l except that it
add an association from a to f dfl instead of raising Not_found.val modify_opt : 'a -> ('b option -> 'b option) -> ('a * 'b) list -> ('a * 'b) listmodify_opt a f l allows to modify the binding for a in l
or absence thereof.val modify_at : int -> ('a -> 'a) -> 'a list -> 'a listmodify_at n f l returns the same list as l
but with nth-value a replaced with f a.Invalid_argument if the index is outside of l boundsval modify_opt_at : int -> ('a -> 'a option) -> 'a list -> 'a listmodify_at_opt n f l returns the same list as l but with
nth-value a removed if f a is None, and replaced by v if
it is Some v.Invalid_argument if the index is outside of l boundsval split_at : int -> 'a list -> 'a list * 'a listsplit_at n l returns two lists l1 and l2, l1 containing the
first n elements of l and l2 the others.Invalid_argument if
n is outside of l size bounds.val split_nth : int -> 'a list -> 'a list * 'a listsplit_at.val remove : 'a list -> 'a -> 'a listremove l x returns the list l without the first element x found
or returns l if no element is equal to x. Elements are compared
using ( = ).val remove_if : ('a -> bool) -> 'a list -> 'a listremove_if cmp l is similar to remove, but with cmp used
instead of ( = ).val remove_at : int -> 'a list -> 'a listremove_at i l returns the list l without the element at index i.Invalid_argument if i is outside of l size bounds.val remove_all : 'a list -> 'a -> 'a listremove_all l x is similar to remove but removes all elements that
are equal to x and not only the first one.val take : int -> 'a list -> 'a listtake n l returns up to the n first elements from list l, if
available.val ntake : int -> 'a list -> 'a list listntake n l cuts l into lists of size at most n.
n must be > 0.Invalid_argument 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]]val drop : int -> 'a list -> 'a listdrop 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 listtake_drop n l is equivalent to (take n l, drop n l)
but is done in one pass.val take_while : ('a -> bool) -> 'a list -> 'a listtake_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 listdrop_while p xs returns the suffix remaining after
take_while p xs.val span : ('a -> bool) -> 'a list -> 'a list * 'a listspan, 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.val nsplit : ('a -> bool) -> 'a list -> 'a list listnsplit, 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 listgroup_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 listinterleave ~first ~last sep [a0;a1;a2;...;an] returns
first; a0; sep; a1; sep; a2; sep; ...; sep; an; last
Abstraction layer.
val enum : 'a list -> 'a BatEnum.tval of_enum : 'a BatEnum.t -> 'a listval backwards : 'a list -> 'a BatEnum.tval of_backwards : 'a BatEnum.t -> 'a listval split : ('a * 'b) list -> 'a list * 'b listsplit [(a0,b0); (a1,b1); ...; (an,bn)] is ([a0; a1; ...; an], [b0;
b1; ...; bn]).
Tail-recursive.val combine : 'a list -> 'b list -> ('a * 'b) listcombine [a0; a1; ...; an] [b0; b1; ...; bn] is
[(a0,b0); (a1,b1); ...; (an,bn)].Different_list_size if the two lists
have different lengths. Tail-recursive.val sort : ('a -> 'a -> int) -> 'a list -> 'a listPervasives.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 listList.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 fast_sort : ('a -> 'a -> int) -> 'a list -> 'a listList.sort or List.stable_sort, whichever is faster
on typical input.val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a listl1 and l2 are sorted according to the
comparison function cmp, merge cmp l1 l2 will return a
sorted list containting 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 listsort_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 listsort_uniqval group : ('a -> 'a -> int) -> 'a list -> 'a list listgroup 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) listList.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[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 listval print : ?first:string ->
?last:string ->
?sep:string ->
('a BatInnerIO.output -> 'b -> unit) ->
'a BatInnerIO.output -> 'b list -> unitval eq : 'a BatOrd.eq -> 'a list BatOrd.eq
val ord : 'a BatOrd.ord -> 'a list BatOrd.ord
val compare : 'a BatOrd.comp -> 'a list BatOrd.compmodule Eq:
module Ord:
module Comp:
val nth : 'a list -> int -> 'aat.val takewhile : ('a -> bool) -> 'a list -> 'a listBatList.take_whileval dropwhile : ('a -> bool) -> 'a list -> 'a listBatList.drop_whileList with functions
behaving slightly differently but having the same name. This is by
design:
the functions meant to override the corresponding functions of List.module Exceptionless:sig..end
module Infix:sig..end
module Labels:sig..end
List with labels.
val (@) : 'a list -> 'a list -> 'a listList.append.