Chapter 6  The OCaml language

6.2  Values

• Base values
• Tuples
• Records
• Arrays
• Variant values
• Polymorphic variants
• Functions
• Objects

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

6.2.1  Base values

Integer numbers

Integer values are integer numbers from −2³⁰ to 2³⁰−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⁶² to 2⁶²−1.

Floating-point numbers

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.

Characters

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.

Character strings

String values are finite sequences of characters. The current implementation supports strings containing up to 2²⁴ − 5 characters (16777211 characters); on 64-bit platforms, the limit is 2⁵⁷ − 9.

6.2.2  Tuples

Tuples of values are written (v₁, …, v_n), standing for the n-tuple of values v₁ to v_n. The current implementation supports tuple of up to 2²² − 1 elements (4194303 elements).

6.2.3  Records

Record values are labeled tuples of values. The record value written { field₁ = v₁; …;  field_n = v_n } associates the value v_i to the record field field_i, for i = 1 … n. The current implementation supports records with up to 2²² − 1 fields (4194303 fields).

6.2.4  Arrays

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

6.2.5  Variant values

Variant values are either a constant constructor, or a non-constant constructor applied to a number of values. The former case is written constr; the latter case is written constr (v₁, ... , v_n ), where the v_i are said to be the arguments of the non-constant constructor constr. The parentheses may be omitted if there is only one argument.

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

The current implementation limits each variant type to have at most 246 non-constant constructors and 2³⁰−1 constant constructors.

6.2.6  Polymorphic variants

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).

6.2.7  Functions

Functional values are mappings from values to values.

6.2.8  Objects

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.