Misc.Stdlib.List(3) | OCaml library | Misc.Stdlib.List(3) |

# NAME

Misc.Stdlib.List - Extensions to the List module

# Module

Module Misc.Stdlib.List

# Documentation

Module **List**

: **sig end**

## Extensions to the List module

*type* **'a** *t* = **'a list**

*val compare* : **('a -> 'a -> int) -> 'a t ->
'a t -> int**

The lexicographic order supported by the provided order. There is no constraint on the relative lengths of the lists.

*val equal* : **('a -> 'a -> bool) -> 'a t -> 'a
t -> bool**

Returns **true** if and only if the given lists have the same
length and content with respect to the given equality function.

*val some_if_all_elements_are_some* : **'a option t -> 'a
t option**

If all elements of the given list are **Some _** then **Some
xs** is returned with the **xs** being the contents of those
**Some** s, with order preserved. Otherwise return **None** .

*val map2_prefix* : **('a -> 'b -> 'c) ->** **'a
t ->** **'b t -> 'c t * 'b t**

**let r1, r2 = map2_prefix f l1 l2** If **l1** is of length
n and **l2 = h2 @ t2** with h2 of length n, r1 is **List.map2 f l1
h1** and r2 is t2.

*val iteri2* : **(int -> 'a -> 'b -> unit) -> 'a
list -> 'b list -> unit**

Same as **List.iter2** , but the function is applied to the
index of the element as first argument (counting from 0)

*val split_at* : **int -> 'a t -> 'a t * 'a t**

**split_at n l** returns the pair **before, after** where
**before** is the **n** first elements of **l** and **after**
the remaining ones. If **l** has less than **n** elements, raises
Invalid_argument.

*val chunks_of* : **int -> 'a t -> 'a t t**

**chunks_of n t** returns a list of nonempty lists whose
concatenation is equal to the original list. Every list has **n**
elements, except for possibly the last list, which may have fewer.
**chunks_of** raises if **n <= 0** .

*val is_prefix* : **equal:('a -> 'a -> bool) -> 'a
list -> of_:'a list -> bool**

Returns **true** if and only if the given list, with respect to
the given equality function on list members, is a prefix of the list
**of_** .

*type* **'a** *longest_common_prefix_result* =
private {

longest_common_prefix : **'a list** ;

first_without_longest_common_prefix : **'a list** ;

second_without_longest_common_prefix : **'a list** ;

}

*val find_and_chop_longest_common_prefix* : **equal:('a
-> 'a -> bool) ->** **first:'a list ->** **second:'a list
-> 'a longest_common_prefix_result**

Returns the longest list that, with respect to the provided equality function, is a prefix of both of the given lists. The input lists, each with such longest common prefix removed, are also returned.

2024-05-31 | OCamldoc |