Bare.List
This part of the module simply shadows some functions from Stdlib.List
with exceptionless variants. As per the design principles of Lwtreslib,
Not_found
or otherwise from unavailability of data return an option
instead,Invalid_argument _
or otherwise from malformedness of input receive an additional parameter to return as an Error
instead,hd xs
is the head (first element) of the list or None
if the list is empty.
tl xs
is the tail of the list (the whole list except the first element) or None
if the list is empty.
nth xs n
is the n
th 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'
.
nth_opt
is an alias for nth
provided for compatibility with Stdlib.List
.
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
.
last_opt xs
is the last element of the list xs
or None
if the list xs
is empty.
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.
find_opt
is an alias for find
provided for compatibility with Stdlib.List
.
find_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.
mem ~equal a l
is true
iff there is an element e
of l
such that equal a e
.
memq a l
is the same as mem ~equal:Stdlib.( == ) a l
: it uses the physical equality.
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.
assoc_opt
is an alias for assoc
provided for compatibility with Stdlib.List
.
assq k kvs
is the same as assoc ~equal:Stdlib.( == ) k kvs
: it uses the physical equality.
assq_opt
is an alias for assq
provided for compatibility with Stdlib.List
.
mem_assoc ~equal k l
is equivalent to Option.is_some @@ assoc ~equal k l
.
remove_assoc ~equal k l
is l
without the first element (k', _)
such that equal k k'
.
remove_assoq k l
is remove_assoc ~equal:Stdlib.( == ) k l
.
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.
length xs
is the number of elements in xs
.
length []
is 0
, length ['x']
is 1
, etc.
rev xs
is a list with the elements appearing in the reverse order as in xs
.
rev ['x'; 'y']
is 'y'; 'x'
concat xs
is a list containing the elements of the elements of xs
.
concat [['x'; 'y']; ['a'; 'b']]
is ['x'; 'y'; 'a'; 'b']
append 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']
rev_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
.
flatten
is an alias for concat
.
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) Stdlib.result
combine ~when_different_lengths l1 l2
is either
Error when_different_lengths
if List.length l1 <> List.length l2
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) Stdlib.result
rev_combine ~when_different_lengths xs ys
is rev (combine ~when_different_lengths xs ys)
but more efficient.
split 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) 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.
val 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.
val 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.
val 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.
val 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.
val 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.
val 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.
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
.
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) Stdlib.result) ->
('a list, 'trace) Stdlib.result
init_e
is a Result-aware variant of init
.
val 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
.
val 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
.
val 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.
val 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.
find_e
is a Result-aware variant of find
.
find_s
is an Lwt-aware variant of find
.
val 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
.
val 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
.
find_map_s
is an Lwt-aware variant of find_map
.
val 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
.
filter 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]
filteri
is similar to filter
but the predicate also receives the element's index as an argument.
find_all
is an alias for filter
.
rev_filter f l
is rev (filter f l)
but more efficient.
rev_filteri f l
is rev (filteri f l)
but more efficient.
rev_filter_some xs
is rev @@ filter_some xs
but more efficient.
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']
.
rev_filter_ok rs
is rev @@ filter_ok rs
but more efficient.
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']
.
rev_filter_error rs
is rev @@ filter_error rs
but more efficient.
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]
.
rev_filter_left es
is rev @@ filter_left es
but more efficient.
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']
.
rev_filter_right es
is rev @@ filter_right es
but more efficient.
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]
.
val 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
.
filter_e
is a Result-aware variant of filter
.
rev_filter_s
is an Lwt-aware variant of rev_filter
.
filter_s
is an Lwt-aware variant of filter
.
val 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
.
val 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
.
val 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.
filter_p
is a variant of filter_s
where the promises are evaluated concurrently.
val 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
.
val filteri_e :
(int -> 'a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list, 'trace) Stdlib.result
filteri_e
is a Result-aware variant of filteri
.
rev_filteri_s
is an Lwt-aware variant of rev_filteri
.
filteri_s
is an Lwt-aware variant of filteri
.
val 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
.
val 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
.
val 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.
filteri_p
is a variant of filteri_s
where the promises are evaluated concurrently.
rev_partition f xs
is let rt, rf = partition f xs in (rev rt, rev rf)
but more efficient.
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
.
rev_partition_map f xs
is let rt, rf = partition_map f xs in (rev rt, rev rf)
but more efficient.
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
.
rev_partition_result rs
is partition_result @@ rev rs
but more efficient.
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.
rev_partition_either rs
is partition_either @@ rev rs
but more efficient.
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.
val rev_partition_e :
('a -> (bool, 'trace) Stdlib.result) ->
'a list ->
('a list * 'a list, 'trace) Stdlib.result
rev_partition_e
is a Result-aware variant of rev_partition
.
val 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
.
rev_partition_s
is an Lwt-aware variant of rev_partition
.
partition_s
is an Lwt-aware variant of partition
.
val 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
.
val 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
.
val 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.
partition_p
is a variant of partition_s
where the promises are evaluated concurrently.
val rev_partition_map_e :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result
rev_partition_map_e
is a Result-aware variant of rev_partition_map
.
val partition_map_e :
('a -> (('b, 'c) Stdlib.Either.t, 'trace) Stdlib.result) ->
'a list ->
('b list * 'c list, 'trace) Stdlib.result
partition_map_e
is a Result-aware variant of partition_map
.
val rev_partition_map_s :
('a -> ('b, 'c) Stdlib.Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.t
rev_partition_map_s
is an Lwt-aware variant of rev_partition_map
.
val partition_map_s :
('a -> ('b, 'c) Stdlib.Either.t Lwt.t) ->
'a list ->
('b list * 'c list) Lwt.t
partition_map_s
is an Lwt-aware variant of partition_map
.
val 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
rev_partition_map_es
is an Lwt-Result-aware variant of rev_partition_map
.
val 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
.
val 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.
val 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.
iter_e
is a Result-aware variant of iter
.
iter_s
is an Lwt-aware variant of iter
.
val 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
.
val 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.
iter_p
is a variant of iter_s
where the promises are evaluated concurrently.
val iteri_e :
(int -> 'a -> (unit, 'trace) Stdlib.result) ->
'a list ->
(unit, 'trace) Stdlib.result
iteri_e
is a Result-aware variant of iteri
.
iteri_s
is an Lwt-aware variant of iteri
.
val 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
.
val 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.
iteri_p
is a variant of iteri_s
where the promises are evaluated concurrently.
map_e
is a Result-aware variant of map
.
map_s
is an Lwt-aware variant of map
.
val 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
.
val 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.
map_p
is a variant of map_s
where the promises are evaluated concurrently.
val mapi_e :
(int -> 'a -> ('b, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result
mapi_e
is a Result-aware variant of mapi
.
mapi_s
is an Lwt-aware variant of mapi
.
val 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
.
val 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.
mapi_p
is a variant of mapi_s
where the promises are evaluated concurrently.
rev_mapi f xs
is rev @@ mapi f xs
but more efficient.
rev_map_e
is a Result-aware variant of rev_map
.
rev_map_s
is an Lwt-aware variant of rev_map
.
val 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
.
val 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.
rev_map_p
is a variant of rev_map_s
where the promises are evaluated concurrently.
val 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
.
rev_mapi_s
is an Lwt-aware variant of rev_mapi
.
val 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
.
val 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.
rev_mapi_p
is a variant of rev_mapi_s
where the promises are evaluated concurrently.
rev_filter_map f xs
is rev @@ filter_map f xs
but more efficient.
val rev_filter_map_e :
('a -> ('b option, 'trace) Stdlib.result) ->
'a list ->
('b list, 'trace) Stdlib.result
rev_filter_map_e
is a Result-aware variant of rev_filter_map
.
val 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
.
rev_filter_map_s
is an Lwt-aware variant of rev_filter_map
.
filter_map f xs
is filter_some @@ map f xs
but more efficient.
filter_map_s
is an Lwt-aware variant of filter_map
.
val rev_filter_map_es :
('a -> ('b option, 'trace) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'trace) Stdlib.result Lwt.t
rev_filter_map_es
is an Lwt-Result-aware variant of rev_filter_map
.
val 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
.
val 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.
filter_map_p
is a variant of filter_map_s
where the promises are evaluated concurrently.
concat_map f xs
is concat (map f xs)
but more efficient.
concat_map_s
is an Lwt-aware variant of concat_map
.
val 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
.
val 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
.
concat_map_p
is a variant of concat_map_s
where the promises are evaluated concurrently.
val 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.
rev_concat_map f xs
is rev (concat_map f xs)
but more efficient.
rev_concat_map_s
is an Lwt-aware variant of rev_concat_map
.
val rev_concat_map_e :
('a -> ('b list, 'error) Stdlib.result) ->
'a list ->
('b list, 'error) Stdlib.result
rev_concat_map_e
is a Result-aware variant of rev_concat_map
.
val rev_concat_map_es :
('a -> ('b list, 'error) Stdlib.result Lwt.t) ->
'a list ->
('b list, 'error) Stdlib.result Lwt.t
rev_concat_map_es
is an Lwt-Result-aware variant of rev_concat_map
.
val 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
.
fold_left_s
is an Lwt-aware variant of fold_left
.
val 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
.
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
.
val 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.
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
.
val 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.
val fold_right_e :
('a -> 'b -> ('b, 'trace) Stdlib.result) ->
'a list ->
'b ->
('b, 'trace) Stdlib.result
This function is not tail-recursive
This function is not tail-recursive
val 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
As mentioned above, there are no _p
and _ep
double-traversors. Use combine
(and variants) to circumvent this.
val 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
val 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
val 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
As mentioned above, there are no _p
and _ep
double-scanners. Use combine
(and variants) to circumvent this.
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.
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)
otherwiseval 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 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.
The comparison and equality functions are those of the OCaml Stdlib
.
The sorting functions are those of the OCaml Stdlib
.
shuffle l
is a list that contains the same elements as l
but in a random order.
merge 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
xs
and of ys
, andcompare
.merge
is not tail-recursive.
The conversion functions are those of the OCaml Stdlib
.