include Bare_sigs.List.S
type 'a t = 'a list = | []| :: of 'a * 'a list
Constructors and some such
Sourceval nil_e : ('a list, 'trace) Stdlib.result Sourceval nil_s : 'a list Lwt.t Sourceval nil_es : ('a list, 'trace) Stdlib.result Lwt.t nil_es is Lwt.return (Ok [])
val cons : 'a -> 'a list -> 'a listSourceval is_empty : 'a list -> bool is_empty xs is true iff xs is []
Safe wrappers
This part of the module simply shadows some functions from Stdlib.List with exceptionless variants. As per the design principles of Lwtreslib,
- functions which may fail with
Not_found or otherwise from unavailability of data return an option instead, - function which may fail with
Invalid_argument _ or otherwise from malformedness of input receive an additional parameter to return as an Error instead, - functions which perform polymorphic comparison receive an additional parameter for monomorphic comparison instead.
Sourceval hd : 'a list -> 'a option hd xs is the head (first element) of the list or None if the list is empty.
Sourceval tl : 'a list -> 'a list option tl xs is the tail of the list (the whole list except the first element) or None if the list is empty.
Sourceval nth : 'a list -> int -> 'a option nth xs n is the nth element of the list or None if the list has fewer than n elements.
For example, nth xs 0 = hd xs and nth ['x'; 'y'] 1 = Some 'y'.
val nth_opt : 'a list -> int -> 'a optionnth_opt is an alias for nth provided for compatibility with Stdlib.List.
Sourceval last : 'a -> 'a list -> 'a last x xs is the last element of the list xs or x if xs is empty.
The primary intended use for last is after destructing a list: match l with | [] -> … | x :: xs -> last x xs but it can also be used for a default value: last default_value_if_empty xs.
Sourceval last_opt : 'a list -> 'a option last_opt xs is the last element of the list xs or None if the list xs is empty.
Sourceval find : ('a -> bool) -> 'a list -> 'a option find predicate xs is the first element x of the list xs such that predicate x is true or None if the list xs has no such element.
val find_opt : ('a -> bool) -> 'a list -> 'a optionfind_opt is an alias for find provided for compatibility with Stdlib.List.
val find_map : ('a -> 'b option) -> 'a list -> 'b optionfind_map f xs applies f to each of the elements of xs until it returns Some _ at which point it is returned. If no such elements are found then it returns None.
Note that it only applies f to a prefix of xs. It doesn't apply f to the elements of xs which are after the found element. Consequently, find_map f xs has better performance and a different semantic than calling map and find separately.
Sourceval mem : equal:('a -> 'a -> bool) -> 'a -> 'a list -> bool mem ~equal a l is true iff there is an element e of l such that equal a e.
val memq : 'a -> 'a list -> boolmemq a l is the same as mem ~equal:Stdlib.( == ) a l: it uses the physical equality.
Sourceval assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option assoc ~equal k kvs is Some v such that (k', v) is the first pair in the list such that equal k' k or None if the list contains no such pair.
Sourceval assoc_opt : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b option assoc_opt is an alias for assoc provided for compatibility with Stdlib.List.
Sourceval assq : 'a -> ('a * 'b) list -> 'b option assq k kvs is the same as assoc ~equal:Stdlib.( == ) k kvs: it uses the physical equality.
val assq_opt : 'a -> ('a * 'b) list -> 'b optionassq_opt is an alias for assq provided for compatibility with Stdlib.List.
Sourceval mem_assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> bool mem_assoc ~equal k l is equivalent to Option.is_some @@ assoc ~equal k l.
val mem_assq : 'a -> ('a * 'b) list -> boolmem_assq k l is mem_assoc ~equal:Stdlib.( == ) k l.
Sourceval remove_assoc :
equal:('a -> 'a -> bool) ->
'a ->
('a * 'b) list ->
('a * 'b) list remove_assoc ~equal k l is l without the first element (k', _) such that equal k k'.
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) listremove_assoq k l is remove_assoc ~equal:Stdlib.( == ) k l.
Initialisation
Sourceval init :
when_negative_length:'trace ->
int ->
(int -> 'a) ->
('a list, 'trace) Stdlib.result init ~when_negative_length n f is a list of n elements f 0, f 1, etc.
If n is negative, it is Error when_negative_length instead.
Basic traversal
val length : 'a list -> intlength xs is the number of elements in xs.
length [] is 0, length ['x'] is 1, etc.
val rev : 'a list -> 'a listrev xs is a list with the elements appearing in the reverse order as in xs.
rev ['x'; 'y'] is 'y'; 'x'
val concat : 'a list list -> 'a listconcat xs is a list containing the elements of the elements of xs.
concat [['x'; 'y']; ['a'; 'b']] is ['x'; 'y'; 'a'; 'b']
val append : 'a list -> 'a list -> 'a listappend xs ys is a list containing the elements of xs and the elements of ys, in this order.
concat ['x'; 'y'] ['a'; 'b'] is ['x'; 'y'; 'a'; 'b']
val rev_append : 'a list -> 'a list -> 'a listrev_append xs ys is append (rev xs) ys but more efficient. In other words, rev_append xs ys is a list containing the elements of xs in reverse order followed by the elements of ys.
There are two main use-cases for rev_append. First, you should use rev_append when the order of elements is unimportant. In this case you simply replace append xs ys with rev_append xs ys.
Second, you can use rev_append on an already reversed list. You may obtain an already reversed list from any of the other rev_* functions of this module, or simply via your own traversal. In this case, you replace, say, append (map f xs) ys with rev_append (rev_map f xs) ys.
val flatten : 'a list list -> 'a listflatten is an alias for concat.
Double-list traversals
These safe-wrappers take an explicit value to handle the case of lists of unequal length. This value is passed as a named parameter: when_different_lengths.
Note that the traversal function passed as argument (if any) is applied to the common prefix of the two lists, even if they are of different lengths. E.g., in map2 f ['x', 'y'] ['a'] the call f 'x' 'a' is made and all its side-effects are performed before the value Error when_different_lengths is returned
Sourceval combine :
when_different_lengths:'trace ->
'a list ->
'b list ->
(('a * 'b) list, 'trace) Stdlib.result combine ~when_different_lengths l1 l2 is either
Error when_different_lengths if List.length l1 <> List.length l2- a list of pairs of elements from
l1 and l2
E.g., combine ~when_different_lengths [] [] is Ok []
E.g., combine ~when_different_lengths [1; 2] ['a'; 'b'] is Ok [(1,'a'); (2, 'b')]
E.g., combine ~when_different_lengths:"wrong" [1] [] is Error "wrong"
Note: combine ~when_different_lengths l1 l2 is equivalent to try Ok (Stdlib.List.combine l1 l2) with Invalid_argument _ -> when_different_lengths
The same equivalence almost holds for the other double traversors below. The notable difference is if the functions passed as argument to the traversors raise the Invalid_argument _ exception.
Sourceval rev_combine :
when_different_lengths:'trace ->
'a list ->
'b list ->
(('a * 'b) list, 'trace) Stdlib.result rev_combine ~when_different_lengths xs ys is rev (combine ~when_different_lengths xs ys) but more efficient.
val split : ('a * 'b) list -> 'a list * 'b listsplit xs is (List.map fst xs, List.map snd xs) but more efficient.
Sourceval iter2 :
when_different_lengths:'trace ->
('a -> 'b -> unit) ->
'a list ->
'b list ->
(unit, 'trace) Stdlib.result iter2 ~when_different_lengths f xs ys is f x0 y0; f x1 y1; ….
Remember that, even if the lists are of different lengths, the function f is applied to the common prefix of xs and ys. This is true for other traversals, but especially relevant to iter which is commonly used for side-effects.
Sourceval map2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result map2 ~when_different_lengths f xs ys is a list with elements f x0 y0, f x1 y1, etc.
Remember that, even if the lists are of different lengths, the function f is applied to the common prefix of xs and ys. Beware of side-effects and computational cost.
Sourceval rev_map2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result rev_map2 ~when_different_lengths f xs ys is Result.map rev @@ map2 ~when_different_lengths f xs ys but more efficient.
Remember that, even if the lists are of different lengths, the function f is applied to the common prefix of xs and ys. Beware of side-effects and computational cost.
Sourceval fold_left2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'a) ->
'a ->
'b list ->
'c list ->
('a, 'trace) Stdlib.result fold_left2 ~when_different_lengths f init xs ys is … (f (f init x0 y0) x1 y1).
Remember that, even if the lists are of different lengths, the function f is applied to the common prefix of xs and ys. Beware of side-effects and computational cost.
Sourceval fold_right2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'c) ->
'a list ->
'b list ->
'c ->
('c, 'trace) Stdlib.result fold_right2 ~when_different_lengths f xs ys init is f x0 y0 (f x1 y1 (…)).
This function is not tail-recursive.
Note that unlike the left-to-right double-list traversors, fold_right2 only calls f if the lists are of the same length.
Sourceval for_all2 :
when_different_lengths:'trace ->
('a -> 'b -> bool) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result for_all2 ~when_different_lengths f xs ys is f x0 y0 && f x1 y1 && ….
The function stops early if it encounters elements xn, yn such that f xn yn is false. (This is consistent with the short-circuit, lazy evaluation strategy of && in the description above.)
Also note that, if such an element is found in the common prefix of xs and ys, then the function returns Ok false even if xs and ys are of different lengths.
Examples:
for_all2 ~when_different_lengths (=) [] [] is Ok true
for_all2 ~when_different_lengths (=) ['x'] ['a'] is Ok false
for_all2 ~when_different_lengths (=) ['x'; 'y'] ['a'] is Ok false
for_all2 ~when_different_lengths (=) ['x'] ['x'] is Ok true
for_all2 ~when_different_lengths (=) ['x'; 'y'] ['x'] is Error when_different_lengths
for_all2 ~when_different_lengths (=) ['x'; 'y'] ['x'; 'b'] is Ok false
for_all2 ~when_different_lengths (=) ['x'; 'y'] ['x'; 'y'; 'c'] is Error when_different_lengths
Remember that, when it returns Error when_different_lengths, the function f has already been applied to the common prefix of xs and ys. Beware of side-effects and computational cost.
Sourceval exists2 :
when_different_lengths:'trace ->
('a -> 'b -> bool) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result exists2 ~when_different_lengths f xs ys is f x0 y0 || f x1 y1 || ….
The function stops early if it encounters elements xn, yn such that f xn yn is true. (This is consistent with the short-circuit, lazy evaluation strategy of || in the description above.)
Also note that, if such an element is found in the common prefix of xs and ys, then the function returns Ok true even if xs and ys are of different lengths.
Examples:
exists2 ~when_different_lengths (=) [] [] is Ok false
exists2 ~when_different_lengths (=) ['x'] ['a'] is Ok false
exists2 ~when_different_lengths (=) ['x'; 'y'] ['a'] is Error when_different_lengths
exists2 ~when_different_lengths (=) ['x'] ['x'] is Ok true
exists2 ~when_different_lengths (=) ['x'; 'y'] ['x'] is Ok true
Remember that, when it returns Error when_different_lengths, the function f has already been applied to the common prefix of xs and ys. Beware of side-effects and computational cost.
Monad-aware variants
The functions below are strict extensions of the standard Stdlib.List module. It is for result-, lwt- and lwt-result-aware variants. The meaning of the suffix is as described above, in Lwtreslib, and in Sigs.Seq.
Initialisation variants
Note that for asynchronous variants (_s, _es, _p, and _ep), if the length parameter is negative, then the promise is returned already fulfilled with Error when_different_lengths.
Sourceval init_e :
when_negative_length:'trace ->
int ->
(int -> ('a, 'trace) Stdlib.result) ->
('a list, 'trace) Stdlib.result init_e is a Result-aware variant of init.
Sourceval init_s :
when_negative_length:'trace ->
int ->
(int -> 'a Lwt.t) ->
('a list, 'trace) Stdlib.result Lwt.t init_s is an Lwt-aware variant of init.
Sourceval init_es :
when_negative_length:'trace ->
int ->
(int -> ('a, 'trace) Stdlib.result Lwt.t) ->
('a list, 'trace) Stdlib.result Lwt.t init_es is an Lwt-Result-aware variant of init.
Sourceval init_ep :
when_negative_length:'error ->
int ->
(int -> ('a, 'error) Stdlib.result Lwt.t) ->
('a list, 'error list) Stdlib.result Lwt.t init_ep is a variant of init_es where the promises are evaluated concurrently.
Sourceval init_p :
when_negative_length:'trace ->
int ->
(int -> 'a Lwt.t) ->
('a list, 'trace) Stdlib.result Lwt.t init_p is a variant of init_s where the promises are evaluated concurrently.
Query variants
Sourceval find_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a option, 'trace) Stdlib.result find_e is a Result-aware variant of find.
Sourceval find_s : ('a -> bool Lwt.t) -> 'a list -> 'a option Lwt.t find_s is an Lwt-aware variant of find.
Sourceval find_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a option, 'trace) Stdlib.result Lwt.t find_es is an Lwt-Result-aware variant of find.
Sourceval find_map_e :
('a -> ('b option, 'trace) Stdlib.result) ->
'a list ->
('b option, 'trace) Stdlib.result find_map_e is a Result-aware variant of find_map.
Sourceval find_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b option Lwt.t find_map_s is an Lwt-aware variant of find_map.
Sourceval find_map_es :
('a -> ('b option, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b option, 'trace) Stdlib.result Lwt.t find_map_es is an Lwt-Result-aware variant of find_map.
val filter : ('a -> bool) -> 'a list -> 'a listfilter f xs is the list of all the elements xn of xs such that f xn is true.
filter (fun x -> x > 10) [0; 2; 19; 22; -1; 3; 11] is [19; 22; 11]
val filteri : (int -> 'a -> bool) -> 'a list -> 'a listfilteri is similar to filter but the predicate also receives the element's index as an argument.
val find_all : ('a -> bool) -> 'a list -> 'a listfind_all is an alias for filter.
Sourceval rev_filter : ('a -> bool) -> 'a list -> 'a list rev_filter f l is rev (filter f l) but more efficient.
Sourceval rev_filteri : (int -> 'a -> bool) -> 'a list -> 'a list rev_filteri f l is rev (filteri f l) but more efficient.
Sourceval rev_filter_some : 'a option list -> 'a list rev_filter_some xs is rev @@ filter_some xs but more efficient.
Sourceval filter_some : 'a option list -> 'a list filter_some extracts all the payloads of the Some variants. The order is preserved.
filter_some [None; Some 'a'; None; None; Some 'z'; Some 'u'] is ['a'; 'z'; 'u'].
Sourceval rev_filter_ok : ('a, 'b) Stdlib.result list -> 'a list rev_filter_ok rs is rev @@ filter_ok rs but more efficient.
Sourceval filter_ok : ('a, 'b) Stdlib.result list -> 'a list filter_ok extracts all the payloads of the Ok variants. The order is preserved.
filter_ok [Error 3; Ok 'a'; Error 3; Error 5; Ok 'z'; Ok 'u'] is ['a'; 'z'; 'u'].
Sourceval rev_filter_error : ('a, 'b) Stdlib.result list -> 'b list rev_filter_error rs is rev @@ filter_error rs but more efficient.
Sourceval filter_error : ('a, 'b) Stdlib.result list -> 'b list filter_error extracts all the payloads of the Error variants. The order is preserved.
filter_ok [Error 3; Ok 'a'; Error 3; Error 5; Ok 'z'; Ok 'u'] is [3; 3; 5].
Sourceval rev_filter_left : ('a, 'b) Stdlib.Either.t list -> 'a list rev_filter_left es is rev @@ filter_left es but more efficient.
Sourceval filter_left : ('a, 'b) Stdlib.Either.t list -> 'a list filter_left extracts all the payloads of the Left variants. The order is preserved.
filter_left [Right 3; Left 'a'; Right 3; Right 5; Left 'z'; Left 'u'] is ['a'; 'z'; 'u'].
Sourceval rev_filter_right : ('a, 'b) Stdlib.Either.t list -> 'b list rev_filter_right es is rev @@ filter_right es but more efficient.
Sourceval filter_right : ('a, 'b) Stdlib.Either.t list -> 'b list filter_right extracts all the payloads of the Right variants. The order is preserved.
filter_right [Right 3; Left 'a'; Right 3; Right 5; Left 'z'; Left 'u'] is [3; 3; 5].
Sourceval rev_filter_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list, 'trace) Stdlib.result rev_filter_e is a Result-aware variant of rev_filter.
Sourceval filter_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list, 'trace) Stdlib.result filter_e is a Result-aware variant of filter.
Sourceval rev_filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t rev_filter_s is an Lwt-aware variant of rev_filter.
Sourceval filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t filter_s is an Lwt-aware variant of filter.
Sourceval rev_filter_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace) Stdlib.result Lwt.t rev_filter_es is an Lwt-Result-aware variant of rev_filter.
Sourceval filter_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace) Stdlib.result Lwt.t filter_es is an Lwt-Result-aware variant of filter.
Sourceval filter_ep :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace list) Stdlib.result Lwt.t filter_ep is a variant of filter_es where the promises are evaluated concurrently.
Sourceval filter_p : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t filter_p is a variant of filter_s where the promises are evaluated concurrently.
Sourceval rev_filteri_e :
(int -> 'a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list, 'trace) Stdlib.result rev_filteri_e is a Result-aware variant of rev_filteri.
Sourceval filteri_e :
(int -> 'a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list, 'trace) Stdlib.result filteri_e is a Result-aware variant of filteri.
Sourceval rev_filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t Sourceval filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t filteri_s is an Lwt-aware variant of filteri.
Sourceval rev_filteri_es :
(int -> 'a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace) Stdlib.result Lwt.t rev_filteri_es is an Lwt-Result-aware variant of rev_filteri.
Sourceval filteri_es :
(int -> 'a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace) Stdlib.result Lwt.t filteri_es is an Lwt-Result-aware variant of filteri.
Sourceval filteri_ep :
(int -> 'a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list, 'trace list) Stdlib.result Lwt.t filteri_ep is a variant of filteri_es where the promises are evaluated concurrently.
Sourceval filteri_p : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.t filteri_p is a variant of filteri_s where the promises are evaluated concurrently.
Sourceval rev_partition : ('a -> bool) -> 'a list -> 'a list * 'a list rev_partition f xs is let rt, rf = partition f xs in (rev rt, rev rf) but more efficient.
Sourceval partition : ('a -> bool) -> 'a list -> 'a list * 'a list partition f xs is a couple of lists (ts, fs) where ts contains all the elements of xs such that f x is true and fs contains all the elements of xs such that f x is false.
The function f is applied once to each element of xs.
Sourceval rev_partition_map :
('a -> ('b, 'c) Stdlib.Either.t) ->
'a list ->
'b list * 'c list rev_partition_map f xs is let rt, rf = partition_map f xs in (rev rt, rev rf) but more efficient.
Sourceval partition_map :
('a -> ('b, 'c) Stdlib.Either.t) ->
'a list ->
'b list * 'c list partition_map f xs applies f to each of the element of xs and returns a couple of lists (ls, rs) where ls contains all the l such that f x is Left l and rs contains all the r such that f x is Right r.
Sourceval rev_partition_result : ('a, 'b) Stdlib.result list -> 'a list * 'b list rev_partition_result rs is partition_result @@ rev rs but more efficient.
Sourceval partition_result : ('a, 'b) Stdlib.result list -> 'a list * 'b list partition_result rs is a tuple of lists (os, es) where os contains all the payloads of Ok variants of rs and es contains all the payloads of Error variants of rs.
partition_result rs is (filter_ok rs, filter_error rs) but more efficient.
Sourceval rev_partition_either : ('a, 'b) Stdlib.Either.t list -> 'a list * 'b list rev_partition_either rs is partition_either @@ rev rs but more efficient.
Sourceval partition_either : ('a, 'b) Stdlib.Either.t list -> 'a list * 'b list partition_either es is a tuple of lists (ls, rs) where ls contains all the payloads of Left variants of ls and rs contains all the payloads of Right variants of es.
partition_either es is (filter_left es, filter_right es) but more efficient.
Sourceval rev_partition_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list * 'a list, 'trace) Stdlib.result Sourceval partition_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list * 'a list, 'trace) Stdlib.result partition_e is a Result-aware variant of partition.
Sourceval rev_partition_s :
('a -> bool Lwt.t) ->
'a list ->
('a list * 'a list) Lwt.t Sourceval partition_s : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.t partition_s is an Lwt-aware variant of partition.
Sourceval rev_partition_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list * 'a list, 'trace) Stdlib.result Lwt.t rev_partition_es is an Lwt-Result-aware variant of rev_partition.
Sourceval partition_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list * 'a list, 'trace) Stdlib.result Lwt.t partition_es is an Lwt-Result-aware variant of partition.
Sourceval partition_ep :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('a list * 'a list, 'trace list) Stdlib.result Lwt.t partition_ep is a variant of partition_es where the promises are evaluated concurrently.
Sourceval partition_p : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.t partition_p is a variant of partition_s where the promises are evaluated concurrently.
Sourceval rev_partition_map_e :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result Sourceval partition_map_e :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result Sourceval rev_partition_map_s :
('a -> ('b, 'c) Stdlib.Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.t Sourceval partition_map_s :
('a -> ('b, 'c) Stdlib.Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.t Sourceval rev_partition_map_es :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result Lwt.t Sourceval partition_map_es :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result Lwt.t partition_map_es is an Lwt-Result-aware variant of partition_map.
Sourceval partition_map_ep :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list * 'c list, 'trace list) Stdlib.result Lwt.t partition_map_ep is a variant of partition_map_es where the promises are evaluated concurrently.
Sourceval partition_map_p :
('a -> ('b, 'c) Stdlib.Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.t partition_map_p is a variant of partition_map_s where the promises are evaluated concurrently.
Traversal variants
val iter : ('a -> unit) -> 'a list -> unititer f xs is f x0; f x1; ….
Sourceval iter_e :
('a -> (unit, 'trace) Stdlib.result) ->
'a list ->
(unit, 'trace) Stdlib.result iter_e is a Result-aware variant of iter.
Sourceval iter_s : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.t iter_s is an Lwt-aware variant of iter.
Sourceval iter_es :
('a -> (unit, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(unit, 'trace) Stdlib.result Lwt.t iter_es is an Lwt-Result-aware variant of iter.
Sourceval iter_ep :
('a -> (unit, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(unit, 'trace list) Stdlib.result Lwt.t iter_ep is a variant of iter_es where the promises are evaluated concurrently.
Sourceval iter_p : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.t iter_p is a variant of iter_s where the promises are evaluated concurrently.
val iteri : (int -> 'a -> unit) -> 'a list -> unititeri f xs is f 0 x0; f 1 x1; ….
Sourceval iteri_e :
(int -> 'a -> (unit, 'trace) Stdlib.result) ->
'a list ->
(unit, 'trace) Stdlib.result iteri_e is a Result-aware variant of iteri.
Sourceval iteri_s : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.t iteri_s is an Lwt-aware variant of iteri.
Sourceval iteri_es :
(int -> 'a -> (unit, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(unit, 'trace) Stdlib.result Lwt.t iteri_es is an Lwt-Result-aware variant of iteri.
Sourceval iteri_ep :
(int -> 'a -> (unit, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(unit, 'trace list) Stdlib.result Lwt.t iteri_ep is a variant of iteri_es where the promises are evaluated concurrently.
Sourceval iteri_p : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.t iteri_p is a variant of iteri_s where the promises are evaluated concurrently.
val map : ('a -> 'b) -> 'a list -> 'b listmap f xs is the list [f x0; f x1; …].
Sourceval map_e :
('a -> ('b, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result map_e is a Result-aware variant of map.
Sourceval map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t map_s is an Lwt-aware variant of map.
Sourceval map_es :
('a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t map_es is an Lwt-Result-aware variant of map.
Sourceval map_ep :
('a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace list) Stdlib.result Lwt.t map_ep is a variant of map_es where the promises are evaluated concurrently.
Sourceval map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t map_p is a variant of map_s where the promises are evaluated concurrently.
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b listmapi f xs is the list [f 0 x0; f 1 x1; …].
Sourceval mapi_e :
(int -> 'a -> ('b, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result mapi_e is a Result-aware variant of mapi.
Sourceval mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t mapi_s is an Lwt-aware variant of mapi.
Sourceval mapi_es :
(int -> 'a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t mapi_es is an Lwt-Result-aware variant of mapi.
Sourceval mapi_ep :
(int -> 'a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace list) Stdlib.result Lwt.t mapi_ep is a variant of mapi_es where the promises are evaluated concurrently.
Sourceval mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t mapi_p is a variant of mapi_s where the promises are evaluated concurrently.
val rev_map : ('a -> 'b) -> 'a list -> 'b listrev_map f xs is rev @@ map f xs but more efficient.
Sourceval rev_mapi : (int -> 'a -> 'b) -> 'a list -> 'b list rev_mapi f xs is rev @@ mapi f xs but more efficient.
Sourceval rev_map_e :
('a -> ('b, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result rev_map_e is a Result-aware variant of rev_map.
Sourceval rev_map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t rev_map_s is an Lwt-aware variant of rev_map.
Sourceval rev_map_es :
('a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t rev_map_es is an Lwt-Result-aware variant of rev_map.
Sourceval rev_map_ep :
('a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace list) Stdlib.result Lwt.t rev_map_ep is a variant of rev_map_es where the promises are evaluated concurrently.
Sourceval rev_map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t rev_map_p is a variant of rev_map_s where the promises are evaluated concurrently.
Sourceval rev_mapi_e :
(int -> 'a -> ('b, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result rev_mapi_e is a Result-aware variant of rev_mapi.
Sourceval rev_mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t rev_mapi_s is an Lwt-aware variant of rev_mapi.
Sourceval rev_mapi_es :
(int -> 'a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t rev_mapi_es is an Lwt-Result-aware variant of rev_mapi.
Sourceval rev_mapi_ep :
(int -> 'a -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace list) Stdlib.result Lwt.t rev_mapi_ep is a variant of rev_mapi_es where the promises are evaluated concurrently.
Sourceval rev_mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.t rev_mapi_p is a variant of rev_mapi_s where the promises are evaluated concurrently.
Sourceval rev_filter_map : ('a -> 'b option) -> 'a list -> 'b list rev_filter_map f xs is rev @@ filter_map f xs but more efficient.
Sourceval rev_filter_map_e :
('a -> ('b option, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result Sourceval filter_map_e :
('a -> ('b option, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result filter_map_e is a Result-aware variant of filter_map.
Sourceval rev_filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t Sourceval filter_map : ('a -> 'b option) -> 'a list -> 'b list filter_map f xs is filter_some @@ map f xs but more efficient.
Sourceval filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t filter_map_s is an Lwt-aware variant of filter_map.
Sourceval rev_filter_map_es :
('a -> ('b option, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t Sourceval filter_map_es :
('a -> ('b option, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t filter_map_es is an Lwt-Result-aware variant of filter_map.
Sourceval filter_map_ep :
('a -> ('b option, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace list) Stdlib.result Lwt.t filter_map_ep is a variant of filter_map_es where the promises are evaluated concurrently.
Sourceval filter_map_p : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.t filter_map_p is a variant of filter_map_s where the promises are evaluated concurrently.
Sourceval concat_map : ('a -> 'b list) -> 'a list -> 'b list concat_map f xs is concat (map f xs) but more efficient.
Sourceval concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t concat_map_s is an Lwt-aware variant of concat_map.
Sourceval concat_map_e :
('a -> ('b list, 'error) Stdlib.result) ->
'a list ->
('b list, 'error) Stdlib.result concat_map_e is a Result-aware variant of concat_map.
Sourceval concat_map_es :
('a -> ('b list, 'error) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'error) Stdlib.result Lwt.t concat_map_es is an Lwt-Result-aware variant of concat_map.
Sourceval concat_map_p : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t concat_map_p is a variant of concat_map_s where the promises are evaluated concurrently.
Sourceval concat_map_ep :
('a -> ('b list, 'error) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'error list) Stdlib.result Lwt.t concat_map_ep is a variant of concat_map_es where the promises are evaluated concurrently.
Sourceval rev_concat_map : ('a -> 'b list) -> 'a list -> 'b list rev_concat_map f xs is rev (concat_map f xs) but more efficient.
Sourceval rev_concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.t Sourceval rev_concat_map_e :
('a -> ('b list, 'error) Stdlib.result) ->
'a list ->
('b list, 'error) Stdlib.result Sourceval rev_concat_map_es :
('a -> ('b list, 'error) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'error) Stdlib.result Lwt.t val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'aSourceval fold_left_e :
('a -> 'b -> ('a, 'trace) Stdlib.result) ->
'a ->
'b list ->
('a, 'trace) Stdlib.result fold_left_e is a Result-aware variant of fold_left.
Sourceval fold_left_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.t fold_left_s is an Lwt-aware variant of fold_left.
Sourceval fold_left_es :
('a -> 'b -> ('a, 'trace) Stdlib.result Lwt.t) ->
'a ->
'b list ->
('a, 'trace) Stdlib.result Lwt.t fold_left_es is an Lwt-Result-aware variant of fold_left.
Sourceval fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list fold_left_map f a xs is a combination of fold_left and map that maps over all elements of xs and threads an accumulator with initial value a through calls to f.
Sourceval fold_left_map_e :
('a -> 'b -> ('a * 'c, 'trace) Stdlib.result) ->
'a ->
'b list ->
('a * 'c list, 'trace) Stdlib.result fold_left_map_e f a xs is a combination of fold_left_e and map_e that maps over all elements of xs and threads an accumulator with initial value a through calls to f. The list is traversed from left to right and the first encountered error is returned.
Sourceval fold_left_map_s :
('a -> 'b -> ('a * 'c) Lwt.t) ->
'a ->
'b list ->
('a * 'c list) Lwt.t fold_left_map_s f a xs is a combination of fold_left_s and map_s that maps over all elements of xs and threads an accumulator with initial value a through calls to f.
Sourceval fold_left_map_es :
('a -> 'b -> ('a * 'c, 'trace) Stdlib.result Lwt.t) ->
'a ->
'b list ->
('a * 'c list, 'trace) Stdlib.result Lwt.t fold_left_map_es f a xs is a combination of fold_left_es and map_es that maps over all elements of xs and threads an accumulator with initial value a through calls to f. The list is traversed from left to right and the first encountered error is returned.
Sourceval fold_left_i : (int -> 'a -> 'b -> 'a) -> 'a -> 'b list -> 'a Sourceval fold_left_i_e :
(int -> 'a -> 'b -> ('a, 'trace) Stdlib.result) ->
'a ->
'b list ->
('a, 'trace) Stdlib.result Sourceval fold_left_i_s : (int -> 'a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.t Sourceval fold_left_i_es :
(int -> 'a -> 'b -> ('a, 'trace) Stdlib.result Lwt.t) ->
'a ->
'b list ->
('a, 'trace) Stdlib.result Lwt.t val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'bThis function is not tail-recursive
Sourceval fold_right_e :
('a -> 'b -> ('b, 'trace) Stdlib.result) ->
'a list ->
'b ->
('b, 'trace) Stdlib.result This function is not tail-recursive
Sourceval fold_right_s : ('a -> 'b -> 'b Lwt.t) -> 'a list -> 'b -> 'b Lwt.t This function is not tail-recursive
Sourceval fold_right_es :
('a -> 'b -> ('b, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b ->
('b, 'trace) Stdlib.result Lwt.t This function is not tail-recursive
Double-traversal variants
As mentioned above, there are no _p and _ep double-traversors. Use combine (and variants) to circumvent this.
Sourceval iter2_e :
when_different_lengths:'trace ->
('a -> 'b -> (unit, 'trace) Stdlib.result) ->
'a list ->
'b list ->
(unit, 'trace) Stdlib.result Sourceval iter2_s :
when_different_lengths:'trace ->
('a -> 'b -> unit Lwt.t) ->
'a list ->
'b list ->
(unit, 'trace) Stdlib.result Lwt.t Sourceval iter2_es :
when_different_lengths:'trace ->
('a -> 'b -> (unit, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
(unit, 'trace) Stdlib.result Lwt.t Sourceval map2_e :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) Stdlib.result) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Sourceval map2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Lwt.t Sourceval map2_es :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Lwt.t Sourceval rev_map2_e :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) Stdlib.result) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Sourceval rev_map2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Lwt.t Sourceval rev_map2_es :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) Stdlib.result Lwt.t Sourceval fold_left2_e :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('a, 'trace) Stdlib.result) ->
'a ->
'b list ->
'c list ->
('a, 'trace) Stdlib.result Sourceval fold_left2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'a Lwt.t) ->
'a ->
'b list ->
'c list ->
('a, 'trace) Stdlib.result Lwt.t Sourceval fold_left2_es :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('a, 'trace) Stdlib.result Lwt.t) ->
'a ->
'b list ->
'c list ->
('a, 'trace) Stdlib.result Lwt.t Sourceval fold_right2_e :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('c, 'trace) Stdlib.result) ->
'a list ->
'b list ->
'c ->
('c, 'trace) Stdlib.result This function is not tail-recursive
Sourceval fold_right2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'c Lwt.t) ->
'a list ->
'b list ->
'c ->
('c, 'trace) Stdlib.result Lwt.t This function is not tail-recursive
Sourceval fold_right2_es :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('c, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
'c ->
('c, 'trace) Stdlib.result Lwt.t This function is not tail-recursive
Scanning variants
val for_all : ('a -> bool) -> 'a list -> boolSourceval for_all_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
(bool, 'trace) Stdlib.result Sourceval for_all_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t Sourceval for_all_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(bool, 'trace) Stdlib.result Lwt.t Sourceval for_all_ep :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(bool, 'trace list) Stdlib.result Lwt.t Sourceval for_all_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t val exists : ('a -> bool) -> 'a list -> boolSourceval exists_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
(bool, 'trace) Stdlib.result Sourceval exists_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t Sourceval exists_es :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(bool, 'trace) Stdlib.result Lwt.t Sourceval exists_ep :
('a -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
(bool, 'trace list) Stdlib.result Lwt.t Sourceval exists_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.t Double-scanning variants
As mentioned above, there are no _p and _ep double-scanners. Use combine (and variants) to circumvent this.
Sourceval for_all2_e :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) Stdlib.result) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Sourceval for_all2_s :
when_different_lengths:'trace ->
('a -> 'b -> bool Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Lwt.t Sourceval for_all2_es :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Lwt.t Sourceval exists2_e :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) Stdlib.result) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Sourceval exists2_s :
when_different_lengths:'trace ->
('a -> 'b -> bool Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Lwt.t Sourceval exists2_es :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) Stdlib.result Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) Stdlib.result Lwt.t Combine variants
These are primarily intended to be used for preprocessing before applying a traversor to the resulting list of pairs. They give alternatives to the when_different_lengths mechanism of the immediate double-traversors above.
In case the semantic of, say, map2_es was unsatisfying, one can use map_es on a combine-preprocessed pair of lists. The different variants of combine give different approaches to different-length handling.
Sourceval combine_drop : 'a list -> 'b list -> ('a * 'b) list combine_drop ll lr is a list l of pairs of elements taken from the common-length prefix of ll and lr. The suffix of whichever list is longer (if any) is dropped.
More formally nth l n is:
None if n >= min (length ll) (length lr)Some (Option.get @@ nth ll n, Option.get @@ nth lr n) otherwise
Sourceval combine_with_leftovers :
'a list ->
'b list ->
('a * 'b) list * ('a list, 'b list) Stdlib.Either.t option combine_with_leftovers ll lr is a tuple (combined, leftover) where combined is combine_drop ll lr and leftover is either Either.Left lsuffix or Either.Right rsuffix depending on which of ll or lr is longer. leftover is None if the two lists have the same length.
Product
Sourceval product : 'a list -> 'b list -> ('a * 'b) list product xs ys is the cartesian product of xs and ys.
In other words product xs ys is a list containing all the pairs (x, y) where x is an element of xs and y is an element of ys.
The order of the elements in the returned list is unspecified.
Comparison and equality
The comparison and equality functions are those of the OCaml Stdlib.
Sourceval compare : ('a -> 'a -> int) -> 'a list -> 'a list -> int val compare_lengths : 'a list -> 'b list -> intval compare_length_with : 'a list -> int -> intSourceval equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool Sorting
The sorting functions are those of the OCaml Stdlib.
val sort : ('a -> 'a -> int) -> 'a list -> 'a listval stable_sort : ('a -> 'a -> int) -> 'a list -> 'a listval fast_sort : ('a -> 'a -> int) -> 'a list -> 'a listval sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a listSourceval shuffle : rng:Stdlib.Random.State.t -> 'a list -> 'a list shuffle l is a list that contains the same elements as l but in a random order.
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a listmerge compare xs ys merges the lists xs and ys.
merge assumes that xs and ys are sorted according to the order defined by compare. If xs and ys are not sorted, the returned value of merge compare xs ys is unspecified.
Assuming that xs and ys are sorted, merge compare xs ys is a list
- containing all the elements of
xs and of ys, and - sorted according to the order defined by
compare.
merge is not tail-recursive.
Conversion
The conversion functions are those of the OCaml Stdlib.
val to_seq : 'a list -> 'a Stdlib.Seq.tval of_seq : 'a Stdlib.Seq.t -> 'a list