package spotlib

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

Module Spot.ListSource

include module type of struct include List 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.0
Sourceval compare_length_with : 'a list -> 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
Sourceval cons : 'a -> 'a list -> 'a list

cons x xs is x :: xs

  • since 4.03.0 (4.05.0 in ListLabels)
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 : 'a list -> int -> 'a

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

  • raises Failure

    if the list is too short.

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

Comparison

Sourceval equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool

equal eq [a1; ...; an] [b1; ..; bm] holds when the two input lists have the same length, and for each pair of elements ai, bi at the same position we have eq ai bi.

Note: the eq function may be called even if the lists have different length. If you know your equality function is costly, you may want to check compare_lengths first.

  • since 4.12.0
Sourceval compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int

compare cmp [a1; ...; an] [b1; ...; bm] performs a lexicographic comparison of the two input lists, using the same 'a -> 'a -> int interface as Stdlib.compare:

  • a1 :: l1 is smaller than a2 :: l2 (negative result) if a1 is smaller than a2, or if they are equal (0 result) and l1 is smaller than l2
  • the empty list [] is strictly smaller than non-empty lists

Note: the cmp function will be called even if the lists have different lengths.

  • since 4.12.0

Iterators

Sourceval iter : ('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.

Sourceval rev_map : ('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.

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

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

Iterators on two lists

Sourceval iter2 : ('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 rev_map2 : ('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.

Sourceval fold_left2 : ('a -> 'b -> 'c -> 'a) -> '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.

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

Sourceval for_all : ('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 : ('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 for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool

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

  • raises Invalid_argument

    if the two lists are determined to have different lengths.

Sourceval exists2 : ('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 -> 'a list -> bool

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

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

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

List searching

Sourceval find : ('a -> bool) -> 'a list -> 'a

find f l returns the first element of the list l that satisfies the predicate f.

  • raises Not_found

    if there is no value that satisfies f in the list l.

Sourceval find_map : ('a -> 'b option) -> 'a list -> 'b option

find_map f l applies f to the elements of l in order, and returns the first result of the form Some v, or None if none exist.

  • since 4.10.0
Sourceval filter : ('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 : ('a -> bool) -> 'a list -> 'a list

find_all is another name for filter.

Sourceval filteri : (int -> 'a -> bool) -> 'a list -> 'a list

Same as filter, 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 4.11.0
Sourceval partition : ('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 : 'a -> ('a * 'b) list -> 'b

assoc a l returns the value associated with key a in the list of pairs l. That is, assoc a [ ...; (a,b); ...] = b if (a,b) is the leftmost binding of a in list l.

  • raises Not_found

    if there is no value associated with a in the list l.

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.0
Sourceval mem_assoc : 'a -> ('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 -> ('a * 'b) list -> bool

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

Lists of pairs

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 sort : ('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, Stdlib.compare is a suitable comparison function. The resulting list is sorted in increasing order. 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.

Sourceval stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list

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

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

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

Sourceval sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list

Same as sort, but also remove duplicates.

  • since 4.02.0 (4.03.0 in ListLabels)

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
include module type of struct include Xlist end

Type

Sourcetype 'a t = 'a list

Construction

Sourceval empty : 'a t

empty = []

Sourceval singleton : 'a -> 'a t

singleton x = [x]

Sourceval make : int -> 'a -> 'a t

make n x returns a list of length n filled with x. Throws Invalid_argument "List.make" when n < 0.

Sourceval init : int -> (int -> 'a) -> 'a t

init n f returns a list of [f 0; f 1; ..; f (n-1)]. Throws Invalid_argument "List.init" when n < 0.

Conversions

Sourceval to_list : 'a t -> 'a list
Sourceval to_array : 'a t -> 'a array
Sourceval of_list : 'a list -> 'a t
Sourceval of_array : 'a array -> 'a t

Basics

Sourceval append : 'a t -> 'a t -> 'a t

Tail recursive version of List.append

Sourceval (@) : 'a t -> 'a t -> 'a t

Tail recursive version of List.(@)

Sourceval concat : 'a t t -> 'a t

Tail recursive version of List.concat

Sourceval flatten : 'a t t -> 'a t

Tail recursive version of List.flatten

Sourceval replicate : 'a t -> int -> 'a t

replicate xs n concatenates the list xs n-times

Folding

Sourceval map : ('a -> 'b) -> 'a list -> 'b list
Sourceval mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
Sourceval map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
Sourceval split : ('a * 'b) list -> 'a list * 'b list
Sourceval merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
Sourceval fold_right : ('a -> 'st -> 'st) -> 'a t -> 'st -> 'st
Sourceval fold_left1 : ('a -> 'a -> 'a) -> 'a list -> 'a

List must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".

Sourceval fold_right1 : ('a -> 'a -> 'a) -> 'a list -> 'a

List must be non-empty. Otherwise, it raises Invalid_argment "fold_left1".

Sourceval concat_map : ('a -> 'b list) -> 'a list -> 'b list

concat_map f xs = concat @@ map f xs but much faster.

Sourceval rev_concat_map : ('a -> 'b list) -> 'a list -> 'b list

concat_map f xs = rev @@ concat @@ map f xs but much faster.

Sourceval map_accum_left : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a t -> 'acc * 'b list

mapAccumL f acc t behaves like a combination of map and fold_left; it applies a function f to each element of a list t, passing an accumulating parameter acc from left to right, and returning a final value of this accumulator together with the new list.

Access

Sourceval last : 'a list -> 'a

The last element of the list. Raises Failure when the argument is . last [1;2;3] = 3

Find and assoc

Sourceval find_opt : ('a -> bool) -> 'a list -> 'a option
Sourceval find_map_opt : ('a -> 'b option) -> 'a list -> 'b option
Sourceval remove_first_match : ('a -> bool) -> 'a list -> 'a list
Sourceval assoc_all : 'a -> ('a * 'b) list -> 'b list
Sourceval assoc_opt : 'a -> ('a * 'b) list -> 'b option
Sourceval remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list

Sublist by index

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

sub_default t pos len returns a sublist of t from the position pos (0-start) and length len.

The region specified by pos and len is trimmed by t: if it exceeds the size of t, it is intersected with the region from 0 and length List.length t. One tricky example is:

sub_default [0;1;2;3;4;5] (-1) 3 = [0;1]

Sourceval take_exn : int -> 'a list -> 'a list
Sourceval drop_exn : int -> 'a list -> 'a list
Sourceval sub : 'a list -> int -> int -> 'a list
Sourceval split_at : int -> 'a list -> 'a list * 'a list

Haskell's splitAt. Always succeeds.

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

Split a list into sub-lists of the fixed length

Sublist by predicate

Sourceval filter_map : ('a -> 'b option) -> 'a list -> 'b list
Sourceval rev_filter_map : ('a -> 'b option) -> 'a list -> 'b list
Sourceval span : ('a -> bool) -> 'a list -> 'a list * 'a list

span p xs extract the longest prefix of xs whose elements satisfy p.

Sourceval partition_map : ('a -> [< `Left of 'left | `Right of 'right ]) -> 'a list -> 'left list * 'right list

Sort and uniq

Sourceval uniq_dup : ('a -> 'a -> bool) -> 'a list -> 'a list * ('a * 'a) list

Filter out duplicate elements using the given equality. The first result list is the list of first unique occurrences, the second result list is the rest, the duplications removed from the first result list, paired with the corresponding element of the first result list.

O(n^2).

Sourceval uniq_dup_sorted : ('a -> 'a -> int) -> 'a list -> 'a list * ('a * 'a) list

Same as uniq_dup but only works for already sorted by the same ordering. O(n log n)

Sourceval unique : 'a list -> 'a list

Haskell's nub. O(n^2)

Sourceval unique_by : ('a -> 'a -> bool) -> 'a list -> 'a list
Sourceval has_dup : ('a -> 'a -> bool) -> 'a list -> ('a * 'a) option

Check the list is a unique list or not, wrt the equality function. If not, it returns a dupe example.

has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (4,5)] = None has_dup (fun x y -> fst x = fst y) [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )

O(n^2)

Sourceval group : 'a list -> 'a list list

group xs returns a list of lists such that the concatenation of the result is equal to the argument. Moreover, each sublist in the result contains only equal elements:

group ['M'; 'i'; 's'; 's'; 'i'; 's'; 's'; 'i'; 'p'; 'p'; 'i'] = [['M'],['i'],['s';'s'];['i'];['s';'s'];['i'];['p';'p'];['i']]

Haskell's group.

Sourceval group_by : ('a -> 'a -> bool) -> 'a list -> 'a list list

Same as group but equality can be given. Haskell's groupBy

Sourceval sort_then_group_by : ('a -> 'a -> int) -> 'a list -> 'a list list

sort then group_by

Composition

Sourceval zip : 'a list -> 'b list -> ('a * 'b) list

Haskell's zip. Like List.combine but does not raise when the lengths are not equal. Tail recursive.

With reference

Sourceval accum : 'a list ref -> 'a -> unit

accum xsref x is equivalent with xsref := x :: !xsref

Sourceval (+::=) : 'a list ref -> 'a -> unit

Same as accum

Integer ranges

Sourceval from_to : int -> int -> int list

from_to f t = [f..t]

Sourceval (--) : int -> int -> int list

Same as from_to. f--t = [f..t]

Sourceval init_from_to : int -> int -> (int -> 'a) -> 'a list

init_from_to f t fn = [fn x | x <- [f..t] ]

Misc

Sourceval intersperse : 'a -> 'a list -> 'a list
Sourceval sum : int list -> int

Monad

include Monad.T with type 'a t := 'a list
Sourceval return : 'a -> 'a list
Sourceval bind : 'a list -> ('a -> 'b list) -> 'b list
Sourceval fmap : ('a -> 'b) -> 'a list -> 'b list

fmap in Haskell

Sourceval liftM : ('a -> 'b) -> 'a list -> 'b list

synonym of fmap

Sourceval fmap2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

fmap2 in Haskell

Sourceval liftM2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list

synonym of fmap2

Sourceval void : 'a list -> unit list
Sourceval seq : 'a list list -> 'a list list

sequence in Haskell. Not tail recursive.

Sourceval seq_ : unit list list -> unit list

sequence_ in Haskell. Not tail recursive.

Sourceval mapM : ('a -> 'b list) -> 'a list -> 'b list list

Not tail recursive by default

Sourceval mapM_ : ('a -> unit list) -> 'a list -> unit list

Not tail recursive by default

Sourceval iteri : (int -> 'a -> unit list) -> 'a list -> unit list

Iteration with index starting from 0. Not tail recursive by default

Sourceval for_ : int -> int -> (int -> unit list) -> unit list

for like iteration. Not tail recursive by default

Sourceval join : 'a list list -> 'a list
Sourcemodule Infix = Xlist.Infix
Sourcemodule Syntax = Xlist.Syntax

Modules

Sourcemodule Stdlib = Xlist.Stdlib

Non tail recursive versions

These non tail recursive versions are from stdlib.

Sourceval (@.) : 'a t -> 'a t -> 'a t

Non tail recursive version of (@)

Sourceval append_ntr : 'a t -> 'a t -> 'a t
Sourceval concat_ntr : 'a t t -> 'a t
Sourceval flatten_ntr : 'a t t -> 'a t
Sourceval map_ntr : ('a -> 'b) -> 'a t -> 'b t
Sourceval mapi_ntr : (int -> 'a -> 'b) -> 'a t -> 'b t
Sourceval fold_right_ntr : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
Sourceval map2_ntr : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
Sourceval fold_right2_ntr : ('a -> 'c -> 'b -> 'b) -> 'a list -> 'c list -> 'b -> 'b
Sourceval remove_assoc_ntr : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval remove_assq_ntr : 'a -> ('a * 'b) list -> ('a * 'b) list
Sourceval split_ntr : ('a * 'b) list -> 'a list * 'b list
Sourceval combine_ntr : 'a list -> 'b list -> ('a * 'b) list
Sourceval merge_ntr : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

Deprecated

Sourceval iter_until : ('a -> [ `Break of 'b | `Continue ]) -> 'a list -> 'b option
  • deprecated Use Base.loop instead.
Sourceval scani_left : (int -> 'a -> 'b -> [< `Continue of 'a | `Stop of 'a ]) -> 'a -> 'b list -> 'a
  • deprecated Use Base.loop instead.
Sourceval is_unique : ('a -> 'b) -> 'a list -> ('a * 'a) option

Check the list is a unique list or not, wrt the key function. If not, it returns a dupe example.

is_unique fst [(1,2); (2,3); (4,5)] = None is_unique fst [(1,2); (2,3); (2,5)] = Some ( (2,3), (2,5) )

  • deprecated Use has_dup
Sourceval sort_then_group : ('a -> 'a -> int) -> 'a list -> 'a list list
  • deprecated Use sort_then_group_by
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct