include module type of ListLabels
Safe version of List.filter.
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 fold_right : ('a ‑> 'b ‑> 'b) ‑> 'a t ‑> 'b ‑> 'b
Safe version of fold_right
.
fold_right f [a1; ...; an] b
is
f a1 (f a2 (... (f an b) ...))
. Not tail-recursive.
val fold_while : f:('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> init:'a ‑> 'b t ‑> 'a
Fold until a stop condition via ('a, `Stop)
is
indicated by the accumulator.
val fold_map : f:('acc ‑> 'a ‑> 'acc * 'b) ‑> init:'acc ‑> 'a list ‑> 'acc * 'b list
fold_map ~f ~init 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 list
fold_map2
is to fold_map
what List.map2
is to List.map
.
val fold_filter_map : f:('acc ‑> 'a ‑> 'acc * 'b option) ‑> init:'acc ‑> 'a list ‑> 'acc * 'b list
fold_filter_map ~f ~init l
is a fold_left
-like function, but also
generates a list of output in a way similar to filter_map.
val fold_flat_map : f:('acc ‑> 'a ‑> 'acc * 'b list) ‑> init:'acc ‑> 'a list ‑> 'acc * 'b list
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 t
init len ~f
is f 0; f 1; ...; f (len-1)
.
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 list
partition_map ~f l
maps f
on l
and gather results in lists:
f x = `Left y
, adds y
to the first list.f x = `Right z
, adds z
to the second list.f x = `Drop
, ignores x
.val sublists_of_len : ?last:('a list ‑> 'a list option) ‑> ?offset:int ‑> len:int ‑> 'a list ‑> 'a list list
sublists_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]
.
See CCList.sublists_of_len for more details.
val intersperse : x:'a ‑> 'a list ‑> 'a list
Insert the first argument between every element of the list.
val interleave : 'a list ‑> 'a list ‑> 'a list
interleave [x1…xn] [y1…ym]
is x1,y1,x2,y2,…
and finishes with
the suffix of the longest list.
val find_pred : f:('a ‑> bool) ‑> 'a t ‑> 'a option
find_pred p l
finds the first element of l
that satisfies p
,
or returns None
if no element satisfies p
.
val find_pred_exn : f:('a ‑> bool) ‑> 'a t ‑> 'a
Unsafe version of find_pred.
val find_map : f:('a ‑> 'b option) ‑> 'a t ‑> 'b option
find_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 option
Like find_map, but also pass the index to the predicate function.
val find_idx : f:('a ‑> bool) ‑> 'a t ‑> (int * 'a) option
find_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
. Tail-recursive.
filter_map ~f l
is the sublist of l
containing only elements for which
f
returns Some e
.
Map and remove elements at the same time.
val sorted_merge : cmp:('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> 'a list
Merges elements from both sorted list.
val sort_uniq : cmp:('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list
Sort the list and remove duplicate elements.
val sorted_merge_uniq : cmp:('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> 'a list
sorted_merge_uniq l1 l2
merges the sorted lists l1
and l2
and
removes duplicates.
val is_sorted : cmp:('a ‑> 'a ‑> int) ‑> 'a list ‑> bool
is_sorted l
returns true
iff l
is sorted (according to given order).
Pervasives.compare
).val sorted_insert : cmp:('a ‑> 'a ‑> int) ‑> ?uniq:bool ‑> 'a ‑> 'a list ‑> 'a list
sorted_insert x l
inserts x
into l
such that, if l
was sorted,
then sorted_insert x l
is sorted too.
x
is already in sorted position in l
, then
x
is not duplicated. Default false
(x
will be inserted in any case).val uniq_succ : eq:('a ‑> 'a ‑> bool) ‑> 'a list ‑> 'a list
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]
.
val group_succ : eq:('a ‑> 'a ‑> bool) ‑> 'a list ‑> 'a list list
group_succ ~eq l
groups together consecutive elements that are equal
according to eq
.
Like map, but the function is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.
val iteri : f:(int ‑> 'a ‑> unit) ‑> 'a t ‑> unit
Like 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.
val foldi : f:('b ‑> int ‑> 'a ‑> 'b) ‑> init:'b ‑> 'a t ‑> 'b
Like fold
but it also passes in the index of each element to the folded function. Tail-recursive.
val get_at_idx : int ‑> 'a t ‑> 'a option
Get 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 ‑> 'a
Get 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).
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.
val range_by : step:int ‑> int ‑> int ‑> int t
range_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.
step=0
.val range : int ‑> int ‑> int t
range i j
iterates on integers from i
to j
included. It works
both for decreasing and increasing ranges.
val range' : int ‑> int ‑> int t
Like range but the second bound is excluded.
For instance range' 0 5 = [0;1;2;3;4]
.
module Assoc : sig ... end
module Ref : sig ... end
val random : 'a random_gen ‑> 'a t random_gen
val random_non_empty : 'a random_gen ‑> 'a t random_gen
val random_len : int ‑> 'a random_gen ‑> 'a t random_gen
val random_choose : 'a t ‑> 'a random_gen
Randomly choose an element in the list.
val random_sequence : 'a random_gen t ‑> 'a t random_gen
It is convenient to open CCList.Infix to access the infix operators without cluttering the scope too much.
module Infix : sig ... end