ogre

Open Generic REpresentation NoSQL Database
IN THIS PACKAGE
Module Ogre . Make . List
val all : 'a t list -> 'a list 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 list -> unit t

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

val sequence : unit t list -> unit t

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

val map : 'a list -> f:( 'a -> 'b t ) -> 'b list 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 list -> 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 list -> 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 list -> init:'b -> f:( 'b -> 'a -> 'b t ) -> 'b t

fold_left is a synonym for fold.

val fold_right : 'a list -> 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 list -> 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 list -> 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 list -> 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 list -> 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 Monads.Std.Monoid.S with type t = 'a) -> 'b list -> 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 list -> 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 list -> 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 list -> f:( 'a -> bool t ) -> 'a list 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 list -> f:( 'a -> 'b option t ) -> 'b list 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.