type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]type 'a printer = Format.formatter -> 'a -> unittype 'a random_gen = Random.State.t -> 'ainclude module type of ListReturn the first element of the given list. Raise Failure "hd" if the list is empty.
Return the given list without its first element. Raise Failure "tl" if the list is empty.
Return the n-th element of the given list. The first element (head of the list) is at position 0. Raise Failure "nth" if the list is too short. Raise Invalid_argument "List.nth" if n is negative.
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.
Concatenate a list of lists. The elements of the argument are all concatenated together (in the same order) to give the result. Not tail-recursive (length of the argument + length of the longest sub-list).
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.
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. Raise Invalid_argument if the two lists are determined to have different lengths.
List.map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn]. Raise Invalid_argument if the two lists are determined to have different lengths. Not tail-recursive.
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 are determined to have different lengths.
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 are determined to have different lengths. Not tail-recursive.
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 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).
Same as List.for_all, but for a two-argument predicate. Raise Invalid_argument if the two lists are determined to have different lengths.
Same as List.exists, but for a two-argument predicate. Raise Invalid_argument if the two lists are determined to have different lengths.
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. Raise Not_found if there is no value that satisfies p in the list l.
find_all is another name for List.filter.
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. Raise Not_found if there is no value associated with a in the list l.
Same as List.assoc, 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.
remove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.
Same as List.remove_assoc, but uses physical equality instead of structural equality to compare keys. Not tail-recursive.
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.
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.
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 empty : 'a tval is_empty : _ t -> boolis_empty l returns true iff l = []
Safe version of List.filter
val fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'bSafe version of fold_right
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ]) -> 'a -> 'b t -> 'aFold until a stop condition via ('a, `Stop) is indicated by the accumulator
fold_map f acc l is a fold_left-like function, but it also maps the list to another list.
scan_left f acc l returns the list [acc; f acc x0; f (f acc x0) x1; …] where x0, x1, etc. are the elements of l
fold_map2 is to fold_map what List.map2 is to List.map.
fold_filter_map f acc l is a fold_left-like function, but also generates a list of output in a way similar to filter_map
fold_flat_map f acc l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd..
count f l counts how much element of l comply with the function f.
val init : int -> (int -> 'a) -> 'a tSimilar to Array.init
Similar to List.combine but tail-recursive.
val combine_gen : 'a list -> 'b list -> ('a * 'b) genA tail-recursive version of List.split.
equivalent to compare (length l1) (length l2) but more efficient.
val compare_length_with : 'a t -> int -> intequivalent to compare (length l) x but more efficient.
Map and flatten at the same time (safe). Evaluation order is not guaranteed.
Cartesian product of the two lists, with the given combinator
Produce the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
[[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
# cartesian_product [[1;2];[];[4;5;6]] = [];;
# cartesian_product [[1;2];[3];[4];[5];[6]] |> sort =
[[1;3;4;5;6];[2;3;4;5;6]];;invariant: cartesian_product l = map_product id l.
map_product_l f l maps each element of l to a list of objects of type 'b using f. We obtain [l1;l2;…;ln] where length l=n and li : 'b list. Then, it returns all the ways of picking exactly one element per li.
All pairs of distinct positions of the list. list_diagonal l will return the list of List.nth i l, List.nth j l if i < j.
partition_map f l maps f on l and gather results in lists:
f x = `Left y, adds y to the first listf x = `Right z, adds z to the second listf x = `Drop, ignores xval sublists_of_len :
?last:('a list -> 'a list option) ->
?offset:int ->
int ->
'a list ->
'a list listsublists_of_len n l returns sub-lists of l that have length n. By default, these sub-lists are non overlapping: sublists_of_len 2 [1;2;3;4;5;6] returns [1;2]; [3;4]; [5;6]
Examples:
sublists_of_len 2 [1;2;3;4;5;6] = [[1;2]; [3;4]; [5;6]]sublists_of_len 2 ~offset:3 [1;2;3;4;5;6] = [1;2];[4;5]sublists_of_len 3 ~last:CCOpt.return [1;2;3;4] = [1;2;3];[4]sublists_of_len 2 [1;2;3;4;5] = [[1;2]; [3;4]]val pure : 'a -> 'a tval return : 'a -> 'a ttake_drop n l returns l1, l2 such that l1 @ l2 = l and length l1 = min (length l) n
take_drop_while p l = take_while p l, drop_while p l
last n l takes the last n elements of l (or less if l doesn't have that many elements
val head_opt : 'a t -> 'a optionFirst element.
val last_opt : 'a t -> 'a optionLast element.
val find_pred : ('a -> bool) -> 'a t -> 'a optionfind_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p
val find_map : ('a -> 'b option) -> 'a t -> 'b optionfind_map f l traverses l, applying f to each element. If for some element x, f x = Some y, then Some y is returned. Otherwise the call returns None
val find_mapi : (int -> 'a -> 'b option) -> 'a t -> 'b optionLike find_map, but also pass the index to the predicate function.
val find_idx : ('a -> bool) -> 'a t -> (int * 'a) optionfind_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds. Otherwise returns None
remove ~x l removes every instance of x from l. Tailrec.
filter_some l retains only elements of the form Some x. Same as filter_map CCFun.id
val keep_ok : ('a, _) Result.result t -> 'a tfilter_some l retains only elements of the form Some x. Same as filter_map CCFun.id
all_some l returns Some l' if all elements of l are of the form Some x, or None otherwise.
val all_ok : ('a, 'err) Result.result t -> ('a t, 'err) Result.resultall_ok l returns Ok l' if all elements of l are of the form Ok x, or Error e otherwise (with the first error met).
Merges elements from both sorted list
Sort the list and remove duplicate elements
sorted_merge_uniq l1 l2 merges the sorted lists l1 and l2 and removes duplicates
is_sorted l returns true iff l is sorted (according to given order)
sorted_insert x l inserts x into l such that, if l was sorted, then sorted_insert x l is sorted too.
uniq_succ l removes duplicate elements that occur one next to the other. Examples: uniq_succ [1;2;1] = [1;2;1] uniq_succ [1;1;2] = [1;2]
group_succ ~eq l groups together consecutive elements that are equal according to eq
val iteri : (int -> 'a -> unit) -> 'a t -> unitval foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a t -> 'bFold on list, with index
val get_at_idx : int -> 'a t -> 'a optionGet by index in the list. If the index is negative, it will get element starting from the end of the list.
val get_at_idx_exn : int -> 'a t -> 'aGet the i-th element, or
Set i-th element (removes the old one), or does nothing if index is too high. If the index is negative, it will set element starting from the end of the list.
Insert at i-th position, between the two existing elements. If the index is too high, append at the end of the list. If the index is negative, it will insert element starting from the end of the list.
Remove element at given index. Does nothing if the index is too high. If the index is negative, it will remove element starting from the end of the list.
Those operations maintain the invariant that the list does not contain duplicates (if it already satisfies it)
add_nodup x set adds x to set if it was not already present. Linear time.
remove_one x set removes one occurrence of x from set. Linear time.
val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a t -> boolMembership to the list. Linear time
Remove duplicates w.r.t the equality predicate. Complexity is quadratic in the length of the list, but the order of elements is preserved. If you wish for a faster de-duplication but do not care about the order, use sort_uniq
List union. Complexity is product of length of inputs.
List intersection. Complexity is product of length of inputs.
val range_by : step:int -> int -> int -> int trange_by ~step i j iterates on integers from i to j included, where the difference between successive elements is step. use a negative step for a decreasing list.
val range : int -> int -> int trange i j iterates on integers from i to j included . It works both for decreasing and increasing ranges
val range' : int -> int -> int tSame as range but the second bound is excluded. For instance range' 0 5 = [0;1;2;3;4]
val (--) : int -> int -> int tInfix alias for range
val (--^) : int -> int -> int tInfix alias for range'
val replicate : int -> 'a -> 'a tReplicate the given element n times
module Assoc : sig ... endmodule Ref : sig ... endmodule type MONAD = sig ... endval random : 'a random_gen -> 'a t random_genval random_non_empty : 'a random_gen -> 'a t random_genval random_len : int -> 'a random_gen -> 'a t random_genval random_choose : 'a t -> 'a random_genRandomly choose an element in the list.
val random_sequence : 'a random_gen t -> 'a t random_genIt is convenient to openCCList.Infix to access the infix operators without cluttering the scope too much.
module Infix : sig ... end