This section describes the kinds of values that are manipulated by Objective Caml programs.

Integer values are integer numbers from −2^{30} to 2^{30}−1, that
is −1073741824 to 1073741823. The implementation may support a
wider range of integer values: on 64-bit platforms, the current
implementation supports integers ranging from −2^{62} to 2^{62}−1.

Floating-point values are numbers in floating-point representation. The current implementation uses double-precision floating-point numbers conforming to the IEEE 754 standard, with 53 bits of mantissa and an exponent ranging from −1022 to 1023.

Character values are represented as 8-bit integers between 0 and 255. Character codes between 0 and 127 are interpreted following the ASCII standard. The current implementation interprets character codes between 128 and 255 following the ISO 8859-1 standard.

String values are finite sequences of characters. The current
implementation supports strings containing up to 2^{24} − 5
characters (16777211 characters); on 64-bit platforms, the limit is
2^{57} − 9.

Tuples of values are written (*v*_{1}, …, *v _{n}*), standing for the

Record values are labeled tuples of values. The record value written
{ *field*_{1} = *v*_{1}; …; *field _{n}* =

Arrays are finite, variable-sized sequences of values of the same
type. The current implementation supports arrays containing up to
2^{22} − 1 elements (4194303 elements) unless the elements are
floating-point numbers (2097151 elements in this case); on 64-bit
platforms, the limit is 2^{54} − 1 for all arrays.

Variant values are either a constant constructor, or a pair of a
non-constant constructor and a value. The former case is written
*constr*; the latter case is written *constr*(*v*), where *v* is said
to be the argument of the non-constant constructor *constr*.

The following constants are treated like built-in constant constructors:

Constant | Constructor |

false | the boolean false |

true | the boolean true |

() | the “unit” value |

[] | the empty list |

The current implementation limits each variant type to have at most 246 non-constant constructors.

Polymorphic variants are an alternate form of variant values, not
belonging explicitly to a predefined variant type, and following
specific typing rules. They can be either constant, written
```*tag-name*, or non-constant, written ```*tag-name*(*v*).

Functional values are mappings from values to values.

Objects are composed of a hidden internal state which is a record of instance variables, and a set of methods for accessing and modifying these variables. The structure of an object is described by the toplevel class that created it.