Module CCList

empty is [].

is_empty l returns true iff l = [].

• Since: 0.11

Safe version of List.map.

Infix version of map with reversed arguments.

• Since: 0.5

cons x l is x::l.

• Since: 0.12

Safe version of List.append. Concatenate two lists.

cons_maybe (Some x) l is x :: l. cons_maybe None l is l.

• Since: 0.13

Like append. Concatenate two lists.

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.

Safe version of fold_right. fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)). Not tail-recursive.

Fold until a stop condition via ('a, `Stop) is indicated by the accumulator.

• Since: 0.8

fold_map f acc l is a fold_left-like function, but it also maps the list to another list.

• Since: 0.14

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.

• Since: 1.2

fold_map2 is to fold_map what List.map2 is to List.map.

• Raises Invalid_argument: if the lists do not have the same length.
• Since: 0.16

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.

• Since: 0.17

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.

• Since: 0.14

count f l counts how much elements of l comply with the function f.

• Since: 1.5

init len f is f 0; f 1; ...; f (len-1).

• Raises Invalid_argument: if len < 0.
• Since: 0.6

Like List.combine but tail-recursive. Transform a pair of lists into a list of pairs: combine [a1; ...; an] [b1; ...; bn] is [(a1,b1); ...; (an,bn)].

• Raises Invalid_argument: if the lists have distinct lengths.
• Since: 1.2

Lazy version of combine. Unlike combine, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list.

• Since: 1.2

A tail-recursive version of List.split. Transform a list of pairs into a pair of lists: split [(a1,b1); ...; (an,bn)] is ([a1; ...; an], [b1; ...; bn]).

Equivalent to compare (length l1) (length l2) but more efficient. Compare the lengths of two lists.

• Since: 1.5

Equivalent to compare (length l) x but more efficient. Compare the length of a list to an integer.

• Since: 1.5

Map and flatten at the same time (safe). Evaluation order is not guaranteed.

Safe flatten. Concatenate a list of lists.

Cartesian product of the two lists, with the given combinator.

Fold on the cartesian product.

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.

• Since: 1.2

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.

• Since: 1.2

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:

• if f x = `Left y, adds y to the first list.
• if f x = `Right z, adds z to the second list.
• if f x = `Drop, ignores x.

• Since: 0.11

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].

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]].

• Parameter offset: the number of elements skipped between two consecutive sub-lists. By default it is n. If offset < n, the sub-lists will overlap; if offset > n, some elements will not appear at all.
• Parameter last: if provided and the last group of elements g is such that length g < n, last g is called. If last g = Some g', g' is appended; otherwise g is dropped. If last = CCOpt.return, it will simply keep the last group. By default, last = fun _ -> None, i.e. the last group is dropped if shorter than n.
• Raises Invalid_argument: if offset <= 0 or n <= 0.
• Since: 1.0

Insert the first argument between every element of the list.

• Since: 2.1

interleave [x1…xn] [y1…ym] is x1,y1,x2,y2,… and finishes with the suffix of the longest list.

• Since: 2.1

pure is return.

funs <*> l is product (fun f x -> f x) funs l.

(<$>) = map.

return x is x.

l >>= f is flat_map f l.

Take the n first elements, drop the rest.

Drop the n first elements, keep the rest.

hd_tl (x :: l) returns hd, l.

• Raises Failure: if the list is empty.
• Since: 0.16

take_drop n l returns l1, l2 such that l1 @ l2 = l and length l1 = min (length l) n.

take_while f l returns the longest prefix of l for which f is true.

• Since: 0.13

drop_while f l drops the longest prefix of l for which f is true.

• Since: 0.13

take_drop_while p l = take_while p l, drop_while p l.

• Since: 1.2

last n l takes the last n elements of l (or less if l doesn't have that many elements).

First element.

• Since: 0.20

Return the given list without its first element.

• Since: 2.0

Last element.

• Since: 0.20

find_pred p l finds the first element of l that satisfies p, or returns None if no element satisfies p.

• Since: 0.11

Safe version of find.

• Since: 1.5

Unsafe version of find_pred.

• Raises Not_found: if no such element is found.
• Since: 0.11

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.

• Since: 0.11

Like find_map, but also pass the index to the predicate function.

• Since: 0.11

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 ~x l removes every instance of x from l. Tail-recursive.

• Parameter eq: equality function.
• Since: 0.11

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.

keep_some l retains only elements of the form Some x. Like filter_map CCFun.id.

• Since: 1.3

keep_ok l retains only elements of the form Ok x.

• Since: 1.3

all_some l returns Some l' if all elements of l are of the form Some x, or None otherwise.

• Since: 1.3

all_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).

• Since: 1.3

Merge 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.

• Since: 0.10

is_sorted l returns true iff l is sorted (according to given order).

• Parameter cmp: the comparison function (default Pervasives.compare).
• Since: 0.17

sorted_insert x l inserts x into l such that, if l was sorted, then sorted_insert x l is sorted too.

• Parameter uniq: if true and x is already in sorted position in l, then x is not duplicated. Default false (x will be inserted in any case).
• Since: 0.17

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].

• Since: 0.10

group_succ ~eq l groups together consecutive elements that are equal according to eq.

• Since: 0.11

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.

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.

Iter on two lists.

• Raises Invalid_argument: when lists do not have the same length.
• Since: 2.0

Like fold but it also passes in the index of each element to the folded function. Tail-recursive.

Fold on two lists, with index.

• Raises Invalid_argument: when lists do not have the same length.
• Since: 2.0

Get by index in the list. If the index is negative, it will get element starting from the end of the list.

Safe version of nth.

• Raises Invalid_argument: if the int is negative.
• Since: 1.5

Get the i-th element, or

• Raises Not_found: if the index is invalid. If the index is negative, it will get element starting from the end of the list.

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.

add_nodup x set adds x to set if it was not already present. Linear time.

• Since: 0.11

remove_one x set removes one occurrence of x from set. Linear time.

• Since: 0.11

Membership to the list. Linear time.

Test for inclusion.

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.

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.

• Raises Invalid_argument: if step=0.
• Since: 0.18

range i j iterates on integers from i to j included. It works both for decreasing and increasing ranges.

Like range but the second bound is excluded. For instance range' 0 5 = [0;1;2;3;4].

Infix alias for range.

Infix alias for range'.

• Since: 0.17

Replicate the given element n times.

Concatenate the list with itself n times.

Like Assoc.get_exn.

• Since: 2.0

Like Assoc.get.

• Since: 1.5

Safe version of assq.

• Since: 1.5

Like Assoc.mem.

• Since: 2.0

Like Assoc.remove.

• Since: 2.0

Randomly choose an element in the list.

• Raises Not_found: if the list is empty.

Return a sequence of the elements of the list.

Build a list from a given sequence. In the result, elements appear in the same order as they did in the source sequence.

Return a gen of the elements of the list.

Build a list from a given gen. In the result, elements appear in the same order as they did in the source gen.

Return a klist of the elements of the list.

Build a list from a given klist. In the result, elements appear in the same order as they did in the source klist.

Print the contents of a list.