Below is the API for the OCaml standard library. It's directly copied over from the OCaml Manual, formatted to the Reason syntax and styled accordingly. The API docs are work-in-progress; we'll be polishing these gradually!

If you're targeting JavaScript, the API docs for BuckleScript includes all of below, plus JS-specific APIs.

`module Num: sig .. end`

Operation on arbitrary-precision numbers.

Numbers (type `num`

) are arbitrary-precision rational numbers,
plus the special elements `1/0`

(infinity) and `0/0`

(undefined).

`type num = `

`|` |
`Int of int` |

`|` |
`Big_int of Big_int.big_int` |

`|` |
`Ratio of Ratio.ratio` |

The type of numbers.

```
let (+/): (num, num) => num;
```

Same as

`Num.add_num`

.```
let add_num: (num, num) => num;
```

Addition

```
let minus_num: num => num;
```

Unary negation.

```
let (-/): (num, num) => num;
```

Same as

`Num.sub_num`

.```
let sub_num: (num, num) => num;
```

Subtraction

```
let ( *\/ ): (num, num) => num;
```

Same as

`Num.mult_num`

.```
let mult_num: (num, num) => num;
```

Multiplication

```
let square_num: num => num;
```

Squaring

```
let (/\/): (num, num) => num;
```

Same as

`Num.div_num`

.```
let div_num: (num, num) => num;
```

Division

```
let quo_num: (num, num) => num;
```

Euclidean division: quotient.

```
let mod_num: (num, num) => num;
```

Euclidean division: remainder.

```
let ( **\/ ): (num, num) => num;
```

Same as

`Num.power_num`

.```
let power_num: (num, num) => num;
```

Exponentiation

```
let abs_num: num => num;
```

Absolute value.

```
let succ_num: num => num;
```

`succ n`

is `n+1`

```
let pred_num: num => num;
```

`pred n`

is `n-1`

```
let incr_num: Pervasives.ref(num) => unit;
```

`incr r`

is `r:=!r+1`

, where `r`

is a reference to a number.```
let decr_num: Pervasives.ref(num) => unit;
```

`decr r`

is `r:=!r-1`

, where `r`

is a reference to a number.```
let is_integer_num: num => bool;
```

Test if a number is an integer

The four following functions approximate a number by an integer :

```
let integer_num: num => num;
```

`integer_num n`

returns the integer closest to `n`

. In case of ties,
rounds towards zero.```
let floor_num: num => num;
```

`floor_num n`

returns the largest integer smaller or equal to `n`

.```
let round_num: num => num;
```

`round_num n`

returns the integer closest to `n`

. In case of ties,
rounds off zero.```
let ceiling_num: num => num;
```

`ceiling_num n`

returns the smallest integer bigger or equal to `n`

.```
let sign_num: num => int;
```

Return

`-1`

, `0`

or `1`

according to the sign of the argument.Comparisons between numbers

```
let (=/): (num, num) => bool;
```

```
let (</): (num, num) => bool;
```

```
let (>/): (num, num) => bool;
```

```
let (<=/): (num, num) => bool;
```

```
let (>=/): (num, num) => bool;
```

```
let (<>/): (num, num) => bool;
```

```
let eq_num: (num, num) => bool;
```

```
let lt_num: (num, num) => bool;
```

```
let le_num: (num, num) => bool;
```

```
let gt_num: (num, num) => bool;
```

```
let ge_num: (num, num) => bool;
```

```
let compare_num: (num, num) => int;
```

Return

`-1`

, `0`

or `1`

if the first argument is less than,
equal to, or greater than the second argument.```
let max_num: (num, num) => num;
```

Return the greater of the two arguments.

```
let min_num: (num, num) => num;
```

Return the smaller of the two arguments.

```
let string_of_num: num => string;
```

Convert a number to a string, using fractional notation.

```
let approx_num_fix: (int, num) => string;
```

See

`Num.approx_num_exp`

.```
let approx_num_exp: (int, num) => string;
```

Approximate a number by a decimal. The first argument is the
required precision. The second argument is the number to
approximate.

`Num.approx_num_fix`

uses decimal notation; the first
argument is the number of digits after the decimal point.
`approx_num_exp`

uses scientific (exponential) notation; the
first argument is the number of digits in the mantissa.```
let num_of_string: string => num;
```

Convert a string to a number.
Raise

`Failure "num_of_string"`

if the given string is not
a valid representation of an integer```
let int_of_num: num => int;
```

```
let num_of_int: int => num;
```

```
let nat_of_num: num => Nat.nat;
```

```
let num_of_nat: Nat.nat => num;
```

```
let num_of_big_int: Big_int.big_int => num;
```

```
let big_int_of_num: num => Big_int.big_int;
```

```
let ratio_of_num: num => Ratio.ratio;
```

```
let num_of_ratio: Ratio.ratio => num;
```

```
let float_of_num: num => float;
```