nonstd

Non-standard mini-library
IN THIS PACKAGE
Module Nonstd . 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 rev : 'a list -> 'a list

List reversal.

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

ListLabels.rev_append l1 l2 reverses l1 and concatenates it to l2. This is equivalent to ListLabels.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).

Iterators
val rev_map : f:( 'a -> 'b ) -> 'a list -> 'b list

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

Iterators on two lists
val iter2 : f:( 'a -> 'b -> unit ) -> 'a list -> 'b list -> unit

ListLabels.iter2 f [a1; ...; an] [b1; ...; bn] calls in turn f a1 b1; ...; f an bn. Raise Invalid_argument if the two lists are determined to have different lengths.

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

ListLabels.map2 f [a1; ...; an] [b1; ...; bn] is [f a1 b1; ...; f an bn]. Raise 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

ListLabels.rev_map2 f l1 l2 gives the same result as ListLabels.rev (ListLabels.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

ListLabels.fold_left2 f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn. Raise 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

ListLabels.fold_right2 f [a1; ...; an] [b1; ...; bn] c is f a1 b1 (f a2 b2 (... (f an bn c) ...)). Raise Invalid_argument if the two lists are determined to have different lengths. Not tail-recursive.

List scanning
val for_all2 : f:( 'a -> 'b -> bool ) -> 'a list -> 'b list -> bool

Same as ListLabels.for_all, but for a two-argument predicate. Raise Invalid_argument if the two lists are determined to have different lengths.

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

Same as ListLabels.exists, but for a two-argument predicate. Raise Invalid_argument if the two lists are determined to have different lengths.

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

mem a l is true if and only if a is equal to an element of l.

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

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

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

find_all is another name for ListLabels.filter.

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

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

Association lists
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)]. Raise Invalid_argument if the two lists have different lengths. Not tail-recursive.

Sorting
val sort : cmp:( 'a -> 'a -> int ) -> 'a list -> 'a list

Sort a list in increasing order according to a comparison function. The comparison function must return 0 if its arguments compare as equal, a positive integer if the first is greater, and a negative integer if the first is smaller (see Array.sort for a complete specification). For example, Pervasives.compare is a suitable comparison function. The resulting list is sorted in increasing order. ListLabels.sort is guaranteed to run in constant heap space (in addition to the size of the result list) and logarithmic stack space.

The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.

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

Same as ListLabels.sort, but the sorting algorithm is guaranteed to be stable (i.e. elements that compare equal are kept in their original order) .

The current implementation uses Merge Sort. It runs in constant heap space and logarithmic stack space.

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

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

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

Same as ListLabels.sort, but also remove duplicates.

  • since 4.02.0
val hd_exn : 'a list -> 'a
val hd : 'a list -> 'a option
val tl_exn : 'a list -> 'a list
val tl : 'a list -> 'a list option
val nth : 'a list -> int -> 'a option
val nth_exn : 'a list -> int -> 'a
val rev_filter : 'a list -> f:( 'a -> bool ) -> 'a list
val filter : 'a list -> f:( 'a -> bool ) -> 'a list
val find_map : 'a list -> f:( 'a -> 'b option ) -> 'b option
val find : 'a list -> f:( 'a -> bool ) -> 'a option
val find_exn : 'a list -> f:( 'a -> bool ) -> 'a
val findi : 'a list -> f:( int -> 'a -> bool ) -> (int * 'a) option
val exists : 'a list -> f:( 'a -> bool ) -> bool

changing the order of arguments on some standard List functions.

val for_all : 'a list -> f:( 'a -> bool ) -> bool
val iter : 'a list -> f:( 'a -> unit ) -> unit
val fold : 'a list -> init:'b -> f:( 'b -> 'a -> 'b ) -> 'b

For the container interface.

val fold_left : 'a list -> init:'b -> f:( 'b -> 'a -> 'b ) -> 'b
val to_array : 'a list -> 'a array
val to_list : 'a -> 'a

Tail recursive versions of standard List module

val slow_append : 'a list -> 'a list -> 'a list
val count_append : 'a list -> 'a list -> int -> 'a list
val append : 'a list -> 'a list -> 'a list
val map_slow : 'a list -> f:( 'a -> 'b ) -> 'b list
val count_map : f:( 'a -> 'b ) -> 'a list -> int -> 'b list
val map : 'a list -> f:( 'a -> 'b ) -> 'b list
val fold_right : 'a list -> f:( 'a -> 'b -> 'b ) -> init:'b -> 'b
val rev_mapi : 'a list -> f:( int -> 'a -> 'b ) -> i:int -> 'b list
val count_mapi : f:( int -> 'a -> 'b ) -> 'a list -> int -> 'b list
val mapi : 'a list -> f:( int -> 'a -> 'b ) -> 'b list
val map2_slow : 'a list -> 'b list -> f:( 'a -> 'b -> 'c ) -> 'c list
val count_map2_exn : f:( 'a -> 'b -> 'c ) -> 'a list -> 'b list -> int -> 'c list
val map2_exn : 'a list -> 'b list -> f:( 'a -> 'b -> 'c ) -> 'c list
val iteri : 'a list -> f:( int -> 'a -> unit ) -> unit
val foldi : 'a list -> f:( int -> 'b -> 'a -> 'b ) -> init:'b -> 'b
val filteri : 'a list -> f:( int -> 'a -> bool ) -> 'a list
val reduce : 'a list -> f:( 'a -> 'a -> 'a ) -> 'a option
val concat_map : 'a list -> f:( 'a -> 'b list ) -> 'b list
val concat_mapi : 'a list -> f:( int -> 'a -> 'b list ) -> 'b list
val merge : 'a list -> 'a list -> cmp:( 'a -> 'a -> int ) -> 'a list
val last : 'a list -> 'a option
val remove_consecutive_duplicates : 'a list -> equal:( 'a -> 'a -> bool ) -> 'a list
val dedup : ?compare:( 'a -> 'a -> int ) -> 'a list -> 'a list
val contains_dup : ?compare:( 'a -> 'a -> int ) -> 'a list -> bool
val find_a_dup : ?compare:( 'a -> 'a -> int ) -> 'a list -> 'a option
val init : int -> f:( int -> 'a ) -> 'a list
val rev_filter_map : 'a list -> f:( 'a -> 'b option ) -> 'b list
val filter_map : 'a list -> f:( 'a -> 'b option ) -> 'b list
val filter_opt : 'a option list -> 'a list
val partition_map : 'a list -> f:( 'a -> [< `Fst of 'b | `Snd of 'c ] ) -> 'b list * 'c list
val split_n : 'a list -> int -> 'a list * 'a list
val take : 'a list -> int -> 'a list
val drop : 'a list -> int -> 'a list
val split_while : 'a list -> f:( 'a -> bool ) -> 'a list * 'a list
val take_while : 'a list -> f:( 'a -> bool ) -> 'a list
val drop_while : 'a list -> f:( 'a -> bool ) -> 'a list
module Assoc : sig ... end
val assoc : [> `Use_sub_module ]
val assq : [> `Use_sub_module ]
val mem_assoc : [> `Use_sub_module ]
val mem_assq : [> `Use_sub_module ]
val remove_assoc : [> `Use_sub_module ]
val remove_assq : [> `Use_sub_module ]