package monads

  1. Overview
  2. Docs
package monads
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.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct