include Bare_sigs.List.S
type 'a t = 'a list = | []| :: of 'a * 'a list
Constructors and some such
val nil_e : ('a list, 'trace) resultval nil_s : 'a list Lwt.tnil_es is Lwt.return (Ok [])
val cons : 'a -> 'a list -> 'a listval is_empty : 'a list -> boolis_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.
val hd : 'a list -> 'a optionhd xs is the head (first element) of the list or None if the list is empty.
val tl : 'a list -> 'a list optiontl xs is the tail of the list (the whole list except the first element) or None if the list is empty.
val nth : 'a list -> int -> 'a optionnth 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.
val last : 'a -> 'a list -> 'alast 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.
val last_opt : 'a list -> 'a optionlast_opt xs is the last element of the list xs or None if the list xs is empty.
val find : ('a -> bool) -> 'a list -> 'a optionfind 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.
val mem : equal:('a -> 'a -> bool) -> 'a -> 'a list -> boolmem ~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.
val assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b optionassoc ~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.
val assoc_opt : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> 'b optionassoc_opt is an alias for assoc provided for compatibility with Stdlib.List.
val assq : 'a -> ('a * 'b) list -> 'b optionassq 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.
val mem_assoc : equal:('a -> 'a -> bool) -> 'a -> ('a * 'b) list -> boolmem_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.
val remove_assoc :
equal:('a -> 'a -> bool) ->
'a ->
('a * 'b) list ->
('a * 'b) listremove_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
val init :
when_negative_length:'trace ->
int ->
(int -> 'a) ->
('a list, 'trace) resultinit ~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
val combine :
when_different_lengths:'trace ->
'a list ->
'b list ->
(('a * 'b) list, 'trace) resultcombine ~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.
val rev_combine :
when_different_lengths:'trace ->
'a list ->
'b list ->
(('a * 'b) list, 'trace) resultrev_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.
val iter2 :
when_different_lengths:'trace ->
('a -> 'b -> unit) ->
'a list ->
'b list ->
(unit, 'trace) resultiter2 ~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.
val map2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c) ->
'a list ->
'b list ->
('c list, 'trace) resultmap2 ~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.
val rev_map2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c) ->
'a list ->
'b list ->
('c list, 'trace) resultrev_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.
val fold_left2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'a) ->
'a ->
'b list ->
'c list ->
('a, 'trace) resultfold_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.
val fold_right2 :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'c) ->
'a list ->
'b list ->
'c ->
('c, 'trace) resultfold_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.
val for_all2 :
when_different_lengths:'trace ->
('a -> 'b -> bool) ->
'a list ->
'b list ->
(bool, 'trace) resultfor_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.
val exists2 :
when_different_lengths:'trace ->
('a -> 'b -> bool) ->
'a list ->
'b list ->
(bool, 'trace) resultexists2 ~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.
val init_e :
when_negative_length:'trace ->
int ->
(int -> ('a, 'trace) result) ->
('a list, 'trace) resultinit_e is a Result-aware variant of init.
val init_s :
when_negative_length:'trace ->
int ->
(int -> 'a Lwt.t) ->
('a list, 'trace) result Lwt.tinit_s is an Lwt-aware variant of init.
val init_es :
when_negative_length:'trace ->
int ->
(int -> ('a, 'trace) result Lwt.t) ->
('a list, 'trace) result Lwt.tinit_es is an Lwt-Result-aware variant of init.
val init_p :
when_negative_length:'trace ->
int ->
(int -> 'a Lwt.t) ->
('a list, 'trace) result Lwt.tinit_p is a variant of init_s where the promises are evaluated concurrently.
Query variants
val find_e :
('a -> (bool, 'trace) result) ->
'a list ->
('a option, 'trace) resultfind_e is a Result-aware variant of find.
val find_s : ('a -> bool Lwt.t) -> 'a list -> 'a option Lwt.tfind_s is an Lwt-aware variant of find.
find_es is an Lwt-Result-aware variant of find.
val find_map_e :
('a -> ('b option, 'trace) result) ->
'a list ->
('b option, 'trace) resultfind_map_e is a Result-aware variant of find_map.
val find_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b option Lwt.tfind_map_s is an Lwt-aware variant of find_map.
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.
val rev_filter : ('a -> bool) -> 'a list -> 'a listrev_filter f l is rev (filter f l) but more efficient.
val rev_filteri : (int -> 'a -> bool) -> 'a list -> 'a listrev_filteri f l is rev (filteri f l) but more efficient.
val rev_filter_some : 'a option list -> 'a listrev_filter_some xs is rev @@ filter_some xs but more efficient.
val filter_some : 'a option list -> 'a listfilter_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'].
val rev_filter_ok : ('a, 'b) result list -> 'a listrev_filter_ok rs is rev @@ filter_ok rs but more efficient.
val filter_ok : ('a, 'b) result list -> 'a listfilter_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'].
val rev_filter_error : ('a, 'b) result list -> 'b listrev_filter_error rs is rev @@ filter_error rs but more efficient.
val filter_error : ('a, 'b) result list -> 'b listfilter_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].
val rev_filter_left : ('a, 'b) Either.t list -> 'a listrev_filter_left es is rev @@ filter_left es but more efficient.
val filter_left : ('a, 'b) Either.t list -> 'a listfilter_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'].
val rev_filter_right : ('a, 'b) Either.t list -> 'b listrev_filter_right es is rev @@ filter_right es but more efficient.
val filter_right : ('a, 'b) Either.t list -> 'b listfilter_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].
val rev_filter_e :
('a -> (bool, 'trace) result) ->
'a list ->
('a list, 'trace) resultrev_filter_e is a Result-aware variant of rev_filter.
val filter_e :
('a -> (bool, 'trace) result) ->
'a list ->
('a list, 'trace) resultfilter_e is a Result-aware variant of filter.
val rev_filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.trev_filter_s is an Lwt-aware variant of rev_filter.
val filter_s : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.tfilter_s is an Lwt-aware variant of filter.
rev_filter_es is an Lwt-Result-aware variant of rev_filter.
filter_es is an Lwt-Result-aware variant of filter.
val filter_p : ('a -> bool Lwt.t) -> 'a list -> 'a list Lwt.tfilter_p is a variant of filter_s where the promises are evaluated concurrently.
val rev_filteri_e :
(int -> 'a -> (bool, 'trace) result) ->
'a list ->
('a list, 'trace) resultrev_filteri_e is a Result-aware variant of rev_filteri.
val filteri_e :
(int -> 'a -> (bool, 'trace) result) ->
'a list ->
('a list, 'trace) resultfilteri_e is a Result-aware variant of filteri.
val rev_filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.tval filteri_s : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.tfilteri_s is an Lwt-aware variant of filteri.
rev_filteri_es is an Lwt-Result-aware variant of rev_filteri.
filteri_es is an Lwt-Result-aware variant of filteri.
val filteri_p : (int -> 'a -> bool Lwt.t) -> 'a list -> 'a list Lwt.tfilteri_p is a variant of filteri_s where the promises are evaluated concurrently.
val rev_partition : ('a -> bool) -> 'a list -> 'a list * 'a listrev_partition f xs is let rt, rf = partition f xs in (rev rt, rev rf) but more efficient.
val partition : ('a -> bool) -> 'a list -> 'a list * 'a listpartition 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.
val rev_partition_map :
('a -> ('b, 'c) Either.t) ->
'a list ->
'b list * 'c listrev_partition_map f xs is let rt, rf = partition_map f xs in (rev rt, rev rf) but more efficient.
val partition_map : ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c listpartition_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.
val rev_partition_result : ('a, 'b) result list -> 'a list * 'b listrev_partition_result rs is partition_result @@ rev rs but more efficient.
val partition_result : ('a, 'b) result list -> 'a list * 'b listpartition_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.
val rev_partition_either : ('a, 'b) Either.t list -> 'a list * 'b listrev_partition_either rs is partition_either @@ rev rs but more efficient.
val partition_either : ('a, 'b) Either.t list -> 'a list * 'b listpartition_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.
val rev_partition_e :
('a -> (bool, 'trace) result) ->
'a list ->
('a list * 'a list, 'trace) resultval partition_e :
('a -> (bool, 'trace) result) ->
'a list ->
('a list * 'a list, 'trace) resultpartition_e is a Result-aware variant of partition.
val rev_partition_s :
('a -> bool Lwt.t) ->
'a list ->
('a list * 'a list) Lwt.tval partition_s : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.tpartition_s is an Lwt-aware variant of partition.
val rev_partition_es :
('a -> (bool, 'trace) result Lwt.t) ->
'a list ->
('a list * 'a list, 'trace) result Lwt.trev_partition_es is an Lwt-Result-aware variant of rev_partition.
partition_es is an Lwt-Result-aware variant of partition.
val partition_p : ('a -> bool Lwt.t) -> 'a list -> ('a list * 'a list) Lwt.tpartition_p is a variant of partition_s where the promises are evaluated concurrently.
val rev_partition_map_e :
('a -> (('b, 'c) Either.t, 'trace) result) ->
'a list ->
('b list * 'c list, 'trace) resultval partition_map_e :
('a -> (('b, 'c) Either.t, 'trace) result) ->
'a list ->
('b list * 'c list, 'trace) resultval rev_partition_map_s :
('a -> ('b, 'c) Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.tval partition_map_s :
('a -> ('b, 'c) Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.tpartition_map_es is an Lwt-Result-aware variant of partition_map.
val partition_map_p :
('a -> ('b, 'c) Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.tpartition_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; ….
val iter_e : ('a -> (unit, 'trace) result) -> 'a list -> (unit, 'trace) resultiter_e is a Result-aware variant of iter.
val iter_s : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.titer_s is an Lwt-aware variant of iter.
iter_es is an Lwt-Result-aware variant of iter.
val iter_p : ('a -> unit Lwt.t) -> 'a list -> unit Lwt.titer_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; ….
val iteri_e :
(int -> 'a -> (unit, 'trace) result) ->
'a list ->
(unit, 'trace) resultiteri_e is a Result-aware variant of iteri.
val iteri_s : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.titeri_s is an Lwt-aware variant of iteri.
iteri_es is an Lwt-Result-aware variant of iteri.
val iteri_p : (int -> 'a -> unit Lwt.t) -> 'a list -> unit Lwt.titeri_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; …].
val map_e : ('a -> ('b, 'trace) result) -> 'a list -> ('b list, 'trace) resultmap_e is a Result-aware variant of map.
val map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.tmap_s is an Lwt-aware variant of map.
map_es is an Lwt-Result-aware variant of map.
val map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.tmap_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; …].
val mapi_e :
(int -> 'a -> ('b, 'trace) result) ->
'a list ->
('b list, 'trace) resultmapi_e is a Result-aware variant of mapi.
val mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.tmapi_s is an Lwt-aware variant of mapi.
mapi_es is an Lwt-Result-aware variant of mapi.
val mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.tmapi_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.
val rev_mapi : (int -> 'a -> 'b) -> 'a list -> 'b listrev_mapi f xs is rev @@ mapi f xs but more efficient.
val rev_map_e :
('a -> ('b, 'trace) result) ->
'a list ->
('b list, 'trace) resultrev_map_e is a Result-aware variant of rev_map.
val rev_map_s : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.trev_map_s is an Lwt-aware variant of rev_map.
rev_map_es is an Lwt-Result-aware variant of rev_map.
val rev_map_p : ('a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.trev_map_p is a variant of rev_map_s where the promises are evaluated concurrently.
val rev_mapi_e :
(int -> 'a -> ('b, 'trace) result) ->
'a list ->
('b list, 'trace) resultrev_mapi_e is a Result-aware variant of rev_mapi.
val rev_mapi_s : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.trev_mapi_s is an Lwt-aware variant of rev_mapi.
rev_mapi_es is an Lwt-Result-aware variant of rev_mapi.
val rev_mapi_p : (int -> 'a -> 'b Lwt.t) -> 'a list -> 'b list Lwt.trev_mapi_p is a variant of rev_mapi_s where the promises are evaluated concurrently.
val rev_filter_map : ('a -> 'b option) -> 'a list -> 'b listrev_filter_map f xs is rev @@ filter_map f xs but more efficient.
val rev_filter_map_e :
('a -> ('b option, 'trace) result) ->
'a list ->
('b list, 'trace) resultval filter_map_e :
('a -> ('b option, 'trace) result) ->
'a list ->
('b list, 'trace) resultfilter_map_e is a Result-aware variant of filter_map.
val rev_filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.tval filter_map : ('a -> 'b option) -> 'a list -> 'b listfilter_map f xs is filter_some @@ map f xs but more efficient.
val filter_map_s : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.tfilter_map_s is an Lwt-aware variant of filter_map.
filter_map_es is an Lwt-Result-aware variant of filter_map.
val filter_map_p : ('a -> 'b option Lwt.t) -> 'a list -> 'b list Lwt.tfilter_map_p is a variant of filter_map_s where the promises are evaluated concurrently.
val concat_map : ('a -> 'b list) -> 'a list -> 'b listconcat_map f xs is concat (map f xs) but more efficient.
val concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.tconcat_map_s is an Lwt-aware variant of concat_map.
val concat_map_e :
('a -> ('b list, 'error) result) ->
'a list ->
('b list, 'error) resultconcat_map_e is a Result-aware variant of concat_map.
concat_map_es is an Lwt-Result-aware variant of concat_map.
val concat_map_p : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.tconcat_map_p is a variant of concat_map_s where the promises are evaluated concurrently.
val rev_concat_map : ('a -> 'b list) -> 'a list -> 'b listrev_concat_map f xs is rev (concat_map f xs) but more efficient.
val rev_concat_map_s : ('a -> 'b list Lwt.t) -> 'a list -> 'b list Lwt.tval rev_concat_map_e :
('a -> ('b list, 'error) result) ->
'a list ->
('b list, 'error) resultval fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'aval fold_left_e :
('a -> 'b -> ('a, 'trace) result) ->
'a ->
'b list ->
('a, 'trace) resultfold_left_e is a Result-aware variant of fold_left.
val fold_left_s : ('a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.tfold_left_s is an Lwt-aware variant of fold_left.
fold_left_es is an Lwt-Result-aware variant of fold_left.
val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c listfold_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.
val fold_left_map_e :
('a -> 'b -> ('a * 'c, 'trace) result) ->
'a ->
'b list ->
('a * 'c list, 'trace) resultfold_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.
val fold_left_map_s :
('a -> 'b -> ('a * 'c) Lwt.t) ->
'a ->
'b list ->
('a * 'c list) Lwt.tfold_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.
val fold_left_map_es :
('a -> 'b -> ('a * 'c, 'trace) result Lwt.t) ->
'a ->
'b list ->
('a * 'c list, 'trace) result Lwt.tfold_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.
val fold_left_i : (int -> 'a -> 'b -> 'a) -> 'a -> 'b list -> 'aval fold_left_i_e :
(int -> 'a -> 'b -> ('a, 'trace) result) ->
'a ->
'b list ->
('a, 'trace) resultval fold_left_i_s : (int -> 'a -> 'b -> 'a Lwt.t) -> 'a -> 'b list -> 'a Lwt.tval fold_left_i_es :
(int -> 'a -> 'b -> ('a, 'trace) result Lwt.t) ->
'a ->
'b list ->
('a, 'trace) result Lwt.tval fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'bThis function is not tail-recursive
val fold_right_e :
('a -> 'b -> ('b, 'trace) result) ->
'a list ->
'b ->
('b, 'trace) resultThis function is not tail-recursive
val fold_right_s : ('a -> 'b -> 'b Lwt.t) -> 'a list -> 'b -> 'b Lwt.tThis function is not tail-recursive
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.
val iter2_e :
when_different_lengths:'trace ->
('a -> 'b -> (unit, 'trace) result) ->
'a list ->
'b list ->
(unit, 'trace) resultval iter2_s :
when_different_lengths:'trace ->
('a -> 'b -> unit Lwt.t) ->
'a list ->
'b list ->
(unit, 'trace) result Lwt.tval iter2_es :
when_different_lengths:'trace ->
('a -> 'b -> (unit, 'trace) result Lwt.t) ->
'a list ->
'b list ->
(unit, 'trace) result Lwt.tval map2_e :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) result) ->
'a list ->
'b list ->
('c list, 'trace) resultval map2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) result Lwt.tval map2_es :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) result Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) result Lwt.tval rev_map2_e :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) result) ->
'a list ->
'b list ->
('c list, 'trace) resultval rev_map2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) result Lwt.tval rev_map2_es :
when_different_lengths:'trace ->
('a -> 'b -> ('c, 'trace) result Lwt.t) ->
'a list ->
'b list ->
('c list, 'trace) result Lwt.tval fold_left2_e :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('a, 'trace) result) ->
'a ->
'b list ->
'c list ->
('a, 'trace) resultval fold_left2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'a Lwt.t) ->
'a ->
'b list ->
'c list ->
('a, 'trace) result Lwt.tval fold_left2_es :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('a, 'trace) result Lwt.t) ->
'a ->
'b list ->
'c list ->
('a, 'trace) result Lwt.tval fold_right2_e :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('c, 'trace) result) ->
'a list ->
'b list ->
'c ->
('c, 'trace) resultThis function is not tail-recursive
val fold_right2_s :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> 'c Lwt.t) ->
'a list ->
'b list ->
'c ->
('c, 'trace) result Lwt.tThis function is not tail-recursive
val fold_right2_es :
when_different_lengths:'trace ->
('a -> 'b -> 'c -> ('c, 'trace) result Lwt.t) ->
'a list ->
'b list ->
'c ->
('c, 'trace) result Lwt.tThis function is not tail-recursive
Scanning variants
val for_all : ('a -> bool) -> 'a list -> boolval for_all_e :
('a -> (bool, 'trace) result) ->
'a list ->
(bool, 'trace) resultval for_all_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.tval for_all_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.tval exists : ('a -> bool) -> 'a list -> boolval exists_e :
('a -> (bool, 'trace) result) ->
'a list ->
(bool, 'trace) resultval exists_s : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.tval exists_p : ('a -> bool Lwt.t) -> 'a list -> bool Lwt.tDouble-scanning variants
As mentioned above, there are no _p and _ep double-scanners. Use combine (and variants) to circumvent this.
val for_all2_e :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) result) ->
'a list ->
'b list ->
(bool, 'trace) resultval for_all2_s :
when_different_lengths:'trace ->
('a -> 'b -> bool Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) result Lwt.tval for_all2_es :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) result Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) result Lwt.tval exists2_e :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) result) ->
'a list ->
'b list ->
(bool, 'trace) resultval exists2_s :
when_different_lengths:'trace ->
('a -> 'b -> bool Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) result Lwt.tval exists2_es :
when_different_lengths:'trace ->
('a -> 'b -> (bool, 'trace) result Lwt.t) ->
'a list ->
'b list ->
(bool, 'trace) result Lwt.tCombine 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.
val combine_drop : 'a list -> 'b list -> ('a * 'b) listcombine_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
val combine_with_leftovers :
'a list ->
'b list ->
('a * 'b) list * ('a list, 'b list) Either.t optioncombine_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
val product : 'a list -> 'b list -> ('a * 'b) listproduct 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.
val compare : ('a -> 'a -> int) -> 'a list -> 'a list -> intval compare_lengths : 'a list -> 'b list -> intval compare_length_with : 'a list -> int -> intval equal : ('a -> 'a -> bool) -> 'a list -> 'a list -> boolSorting
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 listshuffle 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 Seq.tval of_seq : 'a Seq.t -> 'a list