#### containers 3.10 3.9 3.8 3.7 3.6.1 3.6 3.5.1 3.5 3.4 3.3 3.2 3.1 3.0.1 3.0 2.8.1 2.8 2.7 2.6.1 2.6 2.5 2.4.1 2.4 2.3 2.2 2.1 2.0 1.5.2 1.5.1 1.5 1.4 1.3 1.2 1.1 1.0 0.22.1 0.22 0.21 0.20 0.19 0.18 0.17 0.16.1 0.16 0.15 0.14 0.13 0.12 0.11 0.10 0.9 0.8 0.7 0.6.1 0.6 0.5 0.4.1 0.4 0.3.4 0.3.3

A modular, clean and powerful extension of the OCaml standard library
Legend:
Library
Module
Module type
Parameter
Class
Class type
Library containers
Module .
`val (+) : t -> t -> t`

`x + y` is the sum of `x` and `y`. Addition.

`val (-) : t -> t -> t`

`x - y` is the difference of `x` and `y`. Subtraction.

`val (~-) : t -> t`

`~- x` is the negation of `x`. Unary negation.

`val (*) : t -> t -> t`

` x * y` is the product of `x` and `y`. Multiplication.

`val (/) : t -> t -> t`

`x / y` is the integer quotient of `x` and `y`. Integer division. Raise `Division_by_zero` if the second argument `y` is zero. This division rounds the real quotient of its arguments towards zero, as specified for `Stdlib`.(/).

`val (mod) : t -> t -> t`

`x mod y` is the integer remainder of `x / y`. If `y <> zero`, the result of `x mod y` satisfies the following properties: `zero <= x mod y < abs y` and `x = ((x / y) * y) + (x mod y)`. If `y = 0`, `x mod y` raises `Division_by_zero`.

`val (**) : t -> t -> t`

Alias to `pow`

• since 3.0
`val (--) : t -> t -> t iter`

Alias to `range`.

• since 3.0
`val (--^) : t -> t -> t iter`

Alias to `range'`.

• since 3.0
`val (land) : t -> t -> t`

`x land y` is the bitwise logical and of `x` and `y`.

`val (lor) : t -> t -> t`

`x lor y` is the bitwise logical or of `x` and `y`.

`val (lxor) : t -> t -> t`

`x lxor y` is the bitwise logical exclusive or of `x` and `y`.

`val lnot : t -> t`

`lnot x` is the bitwise logical negation of `x` (the bits of `x` are inverted).

`val (lsl) : t -> int -> t`

` x lsl y` shifts `x` to the left by `y` bits, filling in with zeroes. The result is unspecified if `y < 0` or `y >= 64`.

`val (lsr) : t -> int -> t`

`x lsr y` shifts `x` to the right by `y` bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of `x`. The result is unspecified if `y < 0` or `y >= 64`.

`val (asr) : t -> int -> t`

`x asr y` shifts `x` to the right by `y` bits. This is an arithmetic shift: the sign bit of `x` is replicated and inserted in the vacated bits. The result is unspecified if `y < 0` or `y >= 64`.

`val (=) : t -> t -> bool`
`val (<>) : t -> t -> bool`
`val (>) : t -> t -> bool`
`val (>=) : t -> t -> bool`
`val (<=) : t -> t -> bool`
`val (<) : t -> t -> bool`