package monads

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type

The Monad.Collection.S2 interface for sequences

val all : ('a, 'e) M.t Core_kernel.Sequence.t -> ('a Core_kernel.Sequence.t, 'e) M.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, 'e) M.t Core_kernel.Sequence.t -> (unit, 'e) M.t

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

val sequence : (unit, 'e) M.t Core_kernel.Sequence.t -> (unit, 'e) M.t

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

val map : 'a Core_kernel.Sequence.t -> f:('a -> ('b, 'e) M.t) -> ('b Core_kernel.Sequence.t, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> (unit, 'e) M.t) -> (unit, 'e) M.t

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

val fold : 'a Core_kernel.Sequence.t -> init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.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 Core_kernel.Sequence.t -> init:'b -> f:('b -> 'a -> ('b, 'e) M.t) -> ('b, 'e) M.t

fold_left is a synonym for fold.

val fold_right : 'a Core_kernel.Sequence.t -> f:('a -> 'b -> ('b, 'e) M.t) -> init:'b -> ('b, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> 'a -> ('a, 'e) M.t) -> ('a option, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> (bool, 'e) M.t) -> (bool, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> (bool, 'e) M.t) -> (int, 'e) M.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 Core_kernel.Sequence.t -> f:('b -> ('a, 'e) M.t) -> ('a, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> (bool, 'e) M.t) -> ('a option, 'e) M.t

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

val find_map : 'a Core_kernel.Sequence.t -> f:('a -> ('b option, 'e) M.t) -> ('b option, 'e) M.t

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

val filter : 'a Core_kernel.Sequence.t -> f:('a -> (bool, 'e) M.t) -> ('a Core_kernel.Sequence.t, 'e) M.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 Core_kernel.Sequence.t -> f:('a -> ('b option, 'e) M.t) -> ('b Core_kernel.Sequence.t, 'e) M.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.

OCaml

Innovation. Community. Security.