package lsp

  1. Overview
  2. Docs
package lsp
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Stdune.ListSource

include module type of struct include ListLabels end
Sourceval length : 'a list -> int

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

Sourceval 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
Sourceval 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
Sourceval hd : 'a list -> 'a

Return the first element of the given list.

  • raises Failure

    if the list is empty.

Sourceval tl : 'a list -> 'a list

Return the given list without its first element.

  • raises Failure

    if the list is empty.

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

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

List reversal.

Sourceval append : 'a list -> 'a list -> 'a list

append l0 l1 appends l1 to l0. Same function as the infix operator @.

  • since 5.1 this function is tail-recursive.
Sourceval 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.

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

Sourceval flatten : 'a list list -> 'a list

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

Comparison

Iterators

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

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

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

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

  • since 4.00
Sourceval rev_map : f:('a -> 'b) -> 'a list -> 'b list

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

Sourceval fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list

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

  • since 4.11
Sourceval fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc

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

Sourceval fold_right : f:('a -> 'acc -> 'acc) -> 'a list -> init:'acc -> 'acc

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

Iterators on two lists

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

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

Sourceval 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 more efficient.

Sourceval fold_left2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a list -> 'b list -> 'acc

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.

Sourceval fold_right2 : f:('a -> 'b -> 'acc -> 'acc) -> 'a list -> 'b list -> init:'acc -> 'acc

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

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

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

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

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

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

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

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

List searching

Sourceval 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
Sourceval find_index : f:('a -> bool) -> 'a list -> int option

find_index ~f xs returns Some i, where i is the index of the first element of the list xs that satisfies f x, if there is such an element.

It returns None if there is no such element.

  • since 5.1
Sourceval find_mapi : f:(int -> 'a -> 'b option) -> 'a list -> 'b option

Same as find_map, but the predicate is applied to the index of the element as first argument (counting from 0), and the element itself as second argument.

  • since 5.1
Sourceval 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.

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

find_all is another name for filter.

List manipulation

Sourceval take : int -> 'a list -> 'a list

take n l returns the prefix of l of length n, or a copy of l if n > length l.

n must be nonnegative.

  • since 5.3
Sourceval drop : int -> 'a list -> 'a list

drop n l returns the suffix of l after n elements, or [] if n > length l.

n must be nonnegative.

  • since 5.3
Sourceval take_while : f:('a -> bool) -> 'a list -> 'a list

take_while p l is the longest (possibly empty) prefix of l containing only elements that satisfy p.

  • since 5.3
Sourceval drop_while : f:('a -> bool) -> 'a list -> 'a list

drop_while p l is the longest (possibly empty) suffix of l starting at the first element that does not satisfy p.

  • since 5.3
Sourceval 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

Sourceval 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
Sourceval assq : 'a -> ('a * 'b) list -> 'b

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

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

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

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

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

Sourceval 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

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

Sourceval 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

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

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

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

Lists and Sequences

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

Iterate on the list.

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

Create a list from a sequence.

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