stdune

Dune's unstable standard library
Legend:
Library
Module
Module type
Parameter
Class
Class type
Library stdune
Module Stdune . List
include module type of struct include ListLabels end
val length : 'a list -> int

Return the length (number of elements) of the given list.

val compare_lengths : 'a list -> 'b list -> int

Compare the lengths of two lists. compare_lengths l1 l2 is equivalent to compare (length l1) (length l2), except that the computation stops after reaching the end of the shortest list.

  • since 4.05.0
val compare_length_with : 'a list -> len:int -> int

Compare the length of a list to an integer. compare_length_with l len is equivalent to compare (length l) len, except that the computation stops after at most len iterations on the list.

  • since 4.05.0
val hd : 'a list -> 'a

Return the first element of the given list.

  • raises Failure

    if the list is empty.

val tl : 'a list -> 'a list

Return the given list without its first element.

  • raises Failure

    if the list is empty.

val nth_opt : 'a list -> int -> 'a option

Return the n-th element of the given list. The first element (head of the list) is at position 0. Return None if the list is too short.

  • raises Invalid_argument

    if n is negative.

  • since 4.05
val rev : 'a list -> 'a list

List reversal.

val append : 'a list -> 'a list -> 'a list

Concatenate two lists. Same function as the infix operator @. Not tail-recursive (length of the first argument). The @ operator is not tail-recursive either.

val rev_append : 'a list -> 'a list -> 'a list

rev_append l1 l2 reverses l1 and concatenates it with l2. This is equivalent to (rev l1) @ l2, but rev_append is tail-recursive and more efficient.

val concat : 'a list list -> 'a list

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

val flatten : 'a list list -> 'a list

Same as concat. Not tail-recursive (length of the argument + length of the longest sub-list).

Comparison

Iterators

val iter : f:( 'a -> unit ) -> 'a list -> unit

iter ~f [a1; ...; an] applies function f in turn to a1; ...; an. It is equivalent to begin f a1; f a2; ...; f an; () end.

val iteri : f:( int -> 'a -> unit ) -> 'a list -> unit

Same as 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.

  • since 4.00.0
val map : f:( 'a -> 'b ) -> 'a list -> 'b list

map ~f [a1; ...; an] applies function f to a1, ..., an, and builds the list [f a1; ...; f an] with the results returned by f. Not tail-recursive.

val mapi : f:( int -> 'a -> 'b ) -> 'a list -> 'b list

Same as 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. Not tail-recursive.

  • since 4.00.0
val rev_map : f:( 'a -> 'b ) -> 'a list -> 'b list

rev_map ~f l gives the same result as rev (map f l), but is tail-recursive and more efficient.

val fold_left_map : f:( 'a -> 'b -> 'a * 'c ) -> init:'a -> 'b list -> 'a * 'c list

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.

  • since 4.11.0
val fold_left : f:( 'a -> 'b -> 'a ) -> init:'a -> 'b list -> 'a

fold_left ~f ~init [b1; ...; bn] is f (... (f (f init b1) b2) ...) bn.

val fold_right : f:( 'a -> 'b -> 'b ) -> 'a list -> init:'b -> 'b

fold_right ~f [a1; ...; an] ~init is f a1 (f a2 (... (f an init) ...)). Not tail-recursive.

Iterators on two lists

val iter2 : f:( 'a -> 'b -> unit ) -> 'a list -> 'b list -> unit

iter2 ~f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn.

  • raises Invalid_argument

    if the two lists are determined to have different lengths.

val map2 : f:( 'a -> 'b -> 'c ) -> 'a list -> 'b list -> 'c list

map2 ~f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn].

  • raises Invalid_argument

    if the two lists are determined to have different lengths. Not tail-recursive.

val rev_map2 : f:( 'a -> 'b -> 'c ) -> 'a list -> 'b list -> 'c list

rev_map2 ~f l1 l2 gives the same result as rev (map2 f l1 l2), but is tail-recursive and more efficient.

val fold_left2 : f:( 'a -> 'b -> 'c -> 'a ) -> init:'a -> 'b list -> 'c list -> 'a

fold_left2 ~f ~init [a1; ...; an] [b1; ...; bn] is f (... (f (f init a1 b1) a2 b2) ...) an bn.

  • raises Invalid_argument

    if the two lists are determined to have different lengths.

val fold_right2 : f:( 'a -> 'b -> 'c -> 'c ) -> 'a list -> 'b list -> init:'c -> 'c

fold_right2 ~f [a1; ...; an] [b1; ...; bn] ~init is f a1 b1 (f a2 b2 (... (f an bn init) ...)).

  • raises Invalid_argument

    if the two lists are determined to have different lengths. Not tail-recursive.

List scanning

val for_all : f:( 'a -> bool ) -> 'a list -> bool

for_all ~f [a1; ...; an] checks if all elements of the list satisfy the predicate f. That is, it returns (f a1) && (f a2) && ... && (f an) for a non-empty list and true if the list is empty.

val exists : f:( 'a -> bool ) -> 'a list -> bool

exists ~f [a1; ...; an] checks if at least one element of the list satisfies the predicate f. That is, it returns (f a1) || (f a2) || ... || (f an) for a non-empty list and false if the list is empty.

val exists2 : f:( 'a -> 'b -> bool ) -> 'a list -> 'b list -> bool

Same as exists, but for a two-argument predicate.

  • raises Invalid_argument

    if the two lists are determined to have different lengths.

val memq : 'a -> set:'a list -> bool

Same as mem, but uses physical equality instead of structural equality to compare list elements.

List searching

val find_opt : f:( 'a -> bool ) -> 'a list -> 'a option

find ~f l returns the first element of the list l that satisfies the predicate f. Returns None if there is no value that satisfies f in the list l.

  • since 4.05
val filter : f:( 'a -> bool ) -> 'a list -> 'a list

filter ~f l returns all the elements of the list l that satisfy the predicate f. The order of the elements in the input list is preserved.

val find_all : f:( 'a -> bool ) -> 'a list -> 'a list

find_all is another name for filter.

val partition : f:( 'a -> bool ) -> 'a list -> 'a list * 'a list

partition ~f l returns a pair of lists (l1, l2), where l1 is the list of all the elements of l that satisfy the predicate f, and l2 is the list of all the elements of l that do not satisfy f. The order of the elements in the input list is preserved.

Association lists

val assoc_opt : 'a -> ('a * 'b) list -> 'b option

assoc_opt a l returns the value associated with key a in the list of pairs l. That is, assoc_opt a [ ...; (a,b); ...] = Some b if (a,b) is the leftmost binding of a in list l. Returns None if there is no value associated with a in the list l.

  • since 4.05
val assq : 'a -> ('a * 'b) list -> 'b

Same as assoc, but uses physical equality instead of structural equality to compare keys.

val assq_opt : 'a -> ('a * 'b) list -> 'b option

Same as assoc_opt, but uses physical equality instead of structural equality to compare keys.

  • since 4.05.0
val mem_assoc : 'a -> map:('a * 'b) list -> bool

Same as assoc, but simply return true if a binding exists, and false if no bindings exist for the given key.

val mem_assq : 'a -> map:('a * 'b) list -> bool

Same as mem_assoc, but uses physical equality instead of structural equality to compare keys.

val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list

remove_assoc a l returns the list of pairs l without the first pair with key a, if any. Not tail-recursive.

val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list

Same as remove_assoc, but uses physical equality instead of structural equality to compare keys. Not tail-recursive.

Lists of pairs

val split : ('a * 'b) list -> 'a list * 'b list

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

val combine : 'a list -> 'b list -> ('a * 'b) list

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 two lists have different lengths. Not tail-recursive.

Sorting

val fast_sort : cmp:( 'a -> 'a -> int ) -> 'a list -> 'a list

Same as sort or stable_sort, whichever is faster on typical input.

val merge : cmp:( 'a -> 'a -> int ) -> 'a list -> 'a list -> 'a list

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

Iterators

val to_seq : 'a list -> 'a Seq.t

Iterate on the list.

  • since 4.07
val of_seq : 'a Seq.t -> 'a list

Create a list from the iterator.

  • since 4.07
type 'a t = 'a list
val is_empty : _ t -> bool
val is_non_empty : _ t -> bool
val filter_map : 'a t -> f:( 'a -> 'b option ) -> 'b t
val filter_opt : 'a option t -> 'a t
val filteri : 'a t -> f:( int -> 'a -> bool ) -> 'a t
val concat_map : 'a t -> f:( 'a -> 'b t ) -> 'b t
val partition_map : 'a t -> f:( 'a -> ( 'b, 'c ) Either.t ) -> 'b t * 'c t
val rev_map_append : 'a t -> 'b t -> f:( 'a -> 'b ) -> 'b t
val rev_partition_map : 'a t -> f:( 'a -> ( 'b, 'c ) Either.t ) -> 'b t * 'c t
type ('a, 'b) skip_or_either =
| Skip
| Left of 'a
| Right of 'b
val filter_partition_map : 'a t -> f:( 'a -> ( 'b, 'c ) skip_or_either ) -> 'b t * 'c t
val rev_filter_partition_map : 'a t -> f:( 'a -> ( 'b, 'c ) skip_or_either ) -> 'b t * 'c t
val find : 'a t -> f:( 'a -> bool ) -> 'a option
val findi : 'a t -> f:( 'a -> bool ) -> ('a * int) option
val find_exn : 'a t -> f:( 'a -> bool ) -> 'a
val find_map : 'a t -> f:( 'a -> 'b option ) -> 'b option
val last : 'a t -> 'a option
val destruct_last : 'a t -> ('a list * 'a) option
val sort : 'a t -> compare:( 'a -> 'a -> Ordering.t ) -> 'a t
val stable_sort : 'a t -> compare:( 'a -> 'a -> Ordering.t ) -> 'a t
val sort_uniq : 'a t -> compare:( 'a -> 'a -> Ordering.t ) -> 'a t
val compare : 'a t -> 'a t -> compare:( 'a -> 'a -> Ordering.t ) -> Ordering.t
val assoc : ('a * 'b) t -> 'a -> 'b option
val singleton : 'a -> 'a t
val nth : 'a t -> int -> 'a option
val physically_equal : 'a t -> 'a t -> bool
val init : int -> f:( int -> 'a ) -> 'a list
val hd_opt : 'a t -> 'a option
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val hash : ( 'a -> int ) -> 'a list -> int
val cons : 'a -> 'a t -> 'a t
val fold_map : 'a list -> init:'b -> f:( 'b -> 'a -> 'b * 'c ) -> 'b * 'c list
val unzip : ('a * 'b) t -> 'a t * 'b t
val for_all2 : 'a list -> 'b list -> f:( 'a -> 'b -> bool ) -> ( bool, [ `Length_mismatch ] ) result
val reduce : 'a list -> f:( 'a -> 'a -> 'a ) -> 'a option
val min : 'a list -> f:( 'a -> 'a -> Ordering.t ) -> 'a option
val max : 'a list -> f:( 'a -> 'a -> Ordering.t ) -> 'a option
val mem : 'a list -> 'a -> equal:( 'a -> 'a -> bool ) -> bool
val split_while : 'a t -> f:( 'a -> bool ) -> 'a t * 'a t
val truncate : max_length:int -> 'a t -> [> `Not_truncated of 'a t | `Truncated of 'a t ]