module Int: Int;
type t = int;
The type for integer values.
let zero: int;
zero is the integer 0.
let one: int;
one is the integer 1.
let minus_one: int;
minus_one is the integer -1.
let neg: int => int;
neg x is ~-x.
let add: (int, int) => int;
add x y is the addition x + y.
let sub: (int, int) => int;
sub x y is the subtraction x - y.
let mul: (int, int) => int;
mul x y is the multiplication x * y.
let div: (int, int) => int;
div x y is the division x / y. See (/) for details.
let rem: (int, int) => int;
rem x y is the remainder x mod y. See (mod) for details.
let succ: int => int;
succ x is add x 1.
let pred: int => int;
pred x is sub x 1.
let abs: int => int;
abs x is the absolute value of x. That is x if x is positive
and neg x if x is negative. Warning. This may be negative if
the argument is Int.min_int.
let max_int: int;
max_int is the greatest representable integer,
2{^[Sys.int_size - 1]} - 1.
let min_int: int;
min_int is the smallest representable integer,
-2{^[Sys.int_size - 1]}.
let logand: (int, int) => int;
logand x y is the bitwise logical and of x and y.
let logor: (int, int) => int;
logor x y is the bitwise logical or of x and y.
let logxor: (int, int) => int;
logxor x y is the bitwise logical exclusive or of x and y.
let lognot: int => int;
lognot x is the bitwise logical negation of x.
let shift_left: (int, int) => int;
shift_left x n shifts x to the left by n bits. The result
is unspecified if n < 0 or n > Sys.int_size.
let shift_right: (int, int) => int;
shift_right x n shifts x to the right by n bits. This is an
arithmetic shift: the sign bit of x is replicated and inserted
in the vacated bits. The result is unspecified if n < 0 or
n > Sys.int_size.
let shift_right_logical: (int, int) => int;
shift_right x n shifts x to the right by n bits. This is a
logical shift: zeroes are inserted in the vacated bits regardless
of the sign of x. The result is unspecified if n < 0 or
n > Sys.int_size.
let equal: (int, int) => bool;
equal x y is true if and only if x = y.
let compare: (int, int) => int;
compare x y is compare x y but more efficient.
let to_float: int => float;
to_float x is x as a floating point number.
let of_float: float => int;
of_float x truncates x to an integer. The result is
unspecified if the argument is nan or falls outside the range of
representable integers.
let to_string: int => string;
to_string x is the written representation of x in decimal.