Legend:
Library
Module
Module type
Parameter
Class
Class type
`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`