`Core2.Seq`

The Monad.Collection.S2 interface for sequences

`all cs`

performs all computations in `cs`

and returns a list of results in the same order. The order of evaluation is unspecified.

`all_ignore cs`

performs all computations in `cs`

in an unspecified order, and discards the results.

`sequence cs`

performs all computations in `cs`

from left to right.

`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.

`iter xs ~f`

performs `f x`

for each `x`

in `xs`

in the left to right order.

`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.

`fold_left`

is a synonym for `fold`

.

`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.

`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

`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`

`for_all xs ~f`

returns a computation that results in `true`

iff for all `x`

in `xs`

`f x`

evaluates to `true`

.

`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) t) ->
('a, 'e) 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.

`find xs ~f`

returns the first element `x`

of `xs`

for which `f x`

evaluates to `true`

.

`find_map xs ~f`

returns the first computation `f x`

for `x`

in `xs`

which will result in non `None`

.