Module Deferred_or_error.List
All of the List
functions that take a how
argument treat it the following way:
`Sequential
indicates both sequential evaluation of the deferreds, and sequential combination of the results.
`Parallel
indicates parallel evaluation of the deferreds (in the sense that they are all in the scheduler at the same time), and parallel combination of the results. For example, List.iter ~how:`Parallel l ~f
will call f
on each element of l
, creating all of the deferreds, then wait for _all_ of them to finish, then combine any errors (as in Or_error.combine_errors_unit
).
`Max_concurrent_jobs n
acts like `Parallel
in the way it combines the results, but only evaluates n
of the deferreds at a time.
val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b monad) -> 'b monad
val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b monad) -> 'b monad
val find : 'a t -> f:('a -> bool monad) -> 'a option monad
val findi : 'a t -> f:(int -> 'a -> bool monad) -> (int * 'a) option monad
val find_map : 'a t -> f:('a -> 'b option monad) -> 'b option monad
val find_mapi : 'a t -> f:(int -> 'a -> 'b option monad) -> 'b option monad
val exists : 'a t -> f:('a -> bool monad) -> bool monad
val existsi : 'a t -> f:(int -> 'a -> bool monad) -> bool monad
val for_all : 'a t -> f:('a -> bool monad) -> bool monad
val for_alli : 'a t -> f:(int -> 'a -> bool monad) -> bool monad
val all : 'a monad t -> 'a t monad
val all_unit : unit monad t -> unit monad
Deferred iterators
In the following, the default how
is `Sequential
val init : ?how:Async_kernel.Monad_sequence.how -> int -> f:(int -> 'a monad) -> 'a t monad
val iter : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:('a -> unit monad) -> unit monad
val iteri : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:(int -> 'a -> unit monad) -> unit monad
val map : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:('a -> 'b monad) -> 'b t monad
val mapi : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:(int -> 'a -> 'b monad) -> 'b t monad
val filter : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:('a -> bool monad) -> 'a t monad
val filteri : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:(int -> 'a -> bool monad) -> 'a t monad
val filter_map : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:('a -> 'b option monad) -> 'b t monad
val filter_mapi : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:(int -> 'a -> 'b option monad) -> 'b t monad
val concat_map : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:('a -> 'b t monad) -> 'b t monad
val concat_mapi : ?how:Async_kernel.Monad_sequence.how -> 'a t -> f:(int -> 'a -> 'b t monad) -> 'b t monad