# Module `Knowledge.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.