# Objective Caml module ``List''

## Module List: list operations

```val length : 'a list -> int
```
Return the length (number of elements) of the given list.
```val hd : 'a list -> 'a
```
Return the first element of the given list. Raise `Failure "hd"` if the list is empty.
```val tl : 'a list -> 'a list
```
Return the given list without its first element. Raise `Failure "tl"` if the list is empty.
```val nth : 'a list -> int -> 'a
```
Return the n-th element of the given list. The first element (head of the list) is at position 0. Raise `Failure "nth"` if the list is too short.
```val rev : 'a list -> 'a list
```
List reversal.
```val append : 'a list -> 'a list -> 'a list
```
Catenate two lists. Same function as the infix operator `@`.
```val rev_append : 'a list -> 'a list -> 'a list
```
`List.rev_append l1 l2` reverses `l1` and catenates it to `l2`. This is equivalent to `List.rev l1 @ l2`, but is more efficient as no intermediate lists are built.
```val concat  : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
```
Catenate (flatten) a list of lists.

#### Iterators

```val iter : ('a -> unit) -> 'a list -> unit
```
`List.iter f [a1; ...; an]` applies function `f` in turn to `a1; ...; an`. It is equivalent to `begin f a1; f a2; ...; f an; () end`.
```val map : ('a -> 'b) -> 'a list -> 'b list
```
`List.map f [a1; ...; an]` applies function `f` to `a1, ..., an`, and builds the list `[f a1; ...; f an]` with the results returned by `f`.
```val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
```
`List.fold_left f a [b1; ...; bn]` is `f (... (f (f a b1) b2) ...) bn`.
```val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
```
`List.fold_right f [a1; ...; an] b` is `f a1 (f a2 (... (f an b) ...))`.

#### Iterators on two lists

```val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
```
`List.iter2 f [a1; ...; an] [b1; ...; bn]` calls in turn `f a1 b1; ...; f an bn`. Raise `Invalid_argument` if the two lists have different lengths.
```val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
```
`List.map2 f [a1; ...; an] [b1; ...; bn]` is `[f a1 b1; ...; f an bn]`. Raise `Invalid_argument` if the two lists have different lengths.
```val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
```
`List.fold_left2 f a [b1; ...; bn] [c1; ...; cn]` is `f (... (f (f a b1 c1) b2 c2) ...) bn cn`. Raise `Invalid_argument` if the two lists have different lengths.
```val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
```
`List.fold_right2 f [a1; ...; an] [b1; ...; bn] c` is `f a1 b1 (f a2 b2 (... (f an bn c) ...))`. Raise `Invalid_argument` if the two lists have different lengths.

#### List scanning

```val for_all : ('a -> bool) -> 'a list -> bool
```
`for_all p [a1; ...; an]` checks if all elements of the list satisfy the predicate `p`. That is, it returns `(p a1) && (p a2) && ... && (p an)`.
```val exists : ('a -> bool) -> 'a list -> bool
```
`exists p [a1; ...; an]` checks if at least one element of the list satisfies the predicate `p`. That is, it returns `(p a1) || (p a2) || ... || (p an)`.
```val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
```
Same as `for_all` and `exists`, but for a two-argument predicate. Raise `Invalid_argument` if the two lists have different lengths.
```val mem : 'a -> 'a list -> bool
```
`mem a l` is true if and only if `a` is equal to an element of `l`.
```val memq : 'a -> 'a list -> bool
```
Same as `mem`, but uses physical equality instead of structural equality to compare list elements.

#### List searching

```val find : ('a -> bool) -> 'a list -> 'a
```
`find p l` returns the first element of the list `l` that satisfies the predicate `p`. Raise `Not_found` if there is no value that satisfies `p` in the list `l`.
```val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
```
`filter p l` returns all the elements of the list `l` that satisfies the predicate `p`. `find_all` is another name for `filter`.
```val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
```
`partition p l` returns a pair of lists `(l1, l2)`, where `l1` is the list of all the elements of `l` that satisfy the predicate `p`, and `l2` is the list of all the elements of `l` that do not satisfy `p`.

#### Association lists

```val assoc : 'a -> ('a * 'b) list -> 'b
```
`assoc a l` returns the value associated with key `a` in the list of pairs `l`. That is, `assoc a [ ...; (a,b); ...] = b` if `(a,b)` is the leftmost binding of `a` in list `l`. Raise `Not_found` if there is no value associated with `a` in the list `l`.
```val assq : 'a -> ('a * 'b) list -> 'b
```
Same as `assoc`, but uses physical equality instead of structural equality to compare keys.
```val mem_assoc : 'a -> ('a * 'b) list -> bool
```
Same as `assoc`, but simply return true if a binding exists, and false if no bindings exist for the given key.
```val mem_assq : 'a -> ('a * 'b) list -> bool
```
Same as `mem_assoc`, but uses physical equality instead of structural equality to compare keys.
```val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
```
`remove_assoc a l` returns the list of pairs `l` without the first pair with key `a`, if any.
```val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
```
Same as `remove_assq`, but uses physical equality instead of structural equality to compare keys.

#### Lists of pairs

```val split : ('a * 'b) list -> 'a list * 'b list
```
Transform a list of pairs into a pair of lists: `split [(a1,b1); ...; (an,bn)]` is `([a1; ...; an], [b1; ...; bn])`
```val combine : 'a list -> 'b list -> ('a * 'b) list
```
Transform a pair of lists into a list of pairs: `combine ([a1; ...; an], [b1; ...; bn])` is `[(a1,b1); ...; (an,bn)]`. Raise `Invalid_argument` if the two lists have different lengths.

This document was translated from LATEX by HEVEA.