Module Collection.Eager

Eager(C) derives Monad.Collection.S for container C

Parameters

Signature

val all : 'a t T.t -> 'a T.t t

all cs performs all computations in cs and returns a list of results in the same order. The order of evaluation is unspecified.

val all_ignore : 'a t T.t -> unit t

all_ignore cs performs all computations in cs in an unspecified order, and discards the results.

val sequence : unit t T.t -> unit t

sequence cs performs all computations in cs from left to right.

val map : 'a T.t -> f:('a -> 'b t) -> 'b T.t t

map xs ~f returns a container where n'th element is a result of computation f x_n, where x_n is the n'th element of the input container. It is unspecified, in which order the computations are evaluated, and whether all computations are performed.

val iter : 'a T.t -> f:('a -> unit t) -> unit t

iter xs ~f performs f x for each x in xs in the left to right order.

val fold : 'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t

fold xs ~init:s0 ~f folds f over xs in the given monad.

Effectively computes a chain:

              f s0 x0 >>= fun s1 ->
              f s1 x1 >>= fun s2 ->
              ...
              f sN xN

Except that the computation uses a constant stack size.

val fold_left : 'a T.t -> init:'b -> f:('b -> 'a -> 'b t) -> 'b t

fold_left is a synonym for fold.

val fold_right : 'a T.t -> f:('a -> 'b -> 'b t) -> init:'b -> 'b t

fold_right xs ~f ~init:s0 folds f over xs from right to left in the given monad.

Effectively computes a chain:

              f x_N s0     >>= fun s1 ->
              f x_(N-1) s1 >>= fun s2 ->
              ...
              f x0 s_N

Except that the computation uses a constant stack size.

val reduce : 'a T.t -> f:('a -> 'a -> 'a t) -> 'a option t

reduce xs ~f same as fold except that the initial state is obtained from the first element of the container, i.e., computes a sequence

              f x0 x1 >>= fun s1 ->
              f s1 x2 >>= fun s2 ->
              ...
              f sN xN
val exists : 'a T.t -> f:('a -> bool t) -> bool t

exists xs ~f returns a computation that results in true iff there exists an element x in xs such that f x evaluates to true

val for_all : 'a T.t -> f:('a -> bool t) -> bool t

for_all xs ~f returns a computation that results in true iff for all x in xs f x evaluates to true.

val count : 'a T.t -> f:('a -> bool t) -> int t

count xs ~f returns a computation that results to a number of elements of xs for which f evaluates to true. The order of application of f is unspecified.

val map_reduce : (module Monoid.S with type t = 'a) -> 'b T.t -> f:('b -> 'a t) -> 'a t

map_reduce (module Monoid) xs ~f a composition of map and reduce. Effectively the same as map xs ~f and then reduce in Monoid except that no intermediate collections are created.

val find : 'a T.t -> f:('a -> bool t) -> 'a option t

find xs ~f returns the first element x of xs for which f x evaluates to true.

val find_map : 'a T.t -> f:('a -> 'b option t) -> 'b option t

find_map xs ~f returns the first computation f x for x in xs which will result in non None.

val filter : 'a T.t -> f:('a -> bool t) -> 'a T.t t

filter xs ~f returns a computation that contains all the elements of xs for which f evaluated to true. The order of the elements is the same.

val filter_map : 'a T.t -> f:('a -> 'b option t) -> 'b T.t t

filter_map xs ~f is a partial mapping from xs to a collection ys, such that all the elements of xs for which f returned Some value are mapped, while the rest are omitted.