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 :
f:('a -> 'b -> 'a * [ `Stop | `Continue ]) ->
init:'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.
val fold_map2 :
f:('acc -> 'a -> 'b -> 'acc * 'c) ->
init:'acc ->
'a list ->
'b list ->
'acc * 'c listfold_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..
val init : int -> f:(int -> 'a) -> 'a tSimilar to Array.init
Map and flatten at the same time (safe). Evaluation order is not guaranteed.
Cartesian product of the two lists, with the given combinator
Fold on the cartesian product
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.
val partition_map :
f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) ->
'a list ->
'b list * 'c listpartition_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 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
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 : f:('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 : f:('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 : f:(int -> 'a -> 'b option) -> 'a t -> 'b optionLike find_map, but also pass the index to the predicate function.
val find_idx : f:('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 ~key l removes every instance of key from l. Tailrec.
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 : f:(int -> 'a -> unit) -> 'a t -> unitval foldi : f:('b -> int -> 'a -> 'b) -> init:'b -> 'a t -> 'bFold on list, with index
val get_at_idx : int -> 'a t -> 'a optionval 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
Insert at i-th position, between the two existing elements. If the index is too high, append at the end of the list
Remove element at given index. Does nothing if the index is too high.
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 ... endtype 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]type 'a printer = Format.formatter -> 'a -> unittype 'a random_gen = Random.State.t -> 'aval 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