The OCaml Standard library.
This module is automatically opened at the beginning of each compilation. All components of this module can therefore be referred by their short name, without prefixing them by Stdlib.
It particular, it provides the basic operations over the built-in types (numbers, booleans, byte sequences, strings, exceptions, references, lists, arrays, input-output channels, ...) and the standard library modules.
Exceptions
Raise the given exception value
val raise_notrace : exn -> 'aA faster version raise which does not record the backtrace.
val invalid_arg : string -> 'aRaise exception Invalid_argument with the given string.
val failwith : string -> 'aRaise exception Failure with the given string.
The Exit exception is not raised by any library function. It is provided for use in your programs.
Boolean operations
val (&&) : bool -> bool -> boolThe boolean 'and'. Evaluation is sequential, left-to-right: in e1 && e2, e1 is evaluated first, and if it returns false, e2 is not evaluated at all. Right-associative operator, see Ocaml_operators for more information.
val (||) : bool -> bool -> boolThe boolean 'or'. Evaluation is sequential, left-to-right: in e1 || e2, e1 is evaluated first, and if it returns true, e2 is not evaluated at all. Right-associative operator, see Ocaml_operators for more information.
Debugging
__LOC__ returns the location at which this expression appears in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
__FILE__ returns the name of the file currently being parsed by the compiler.
__LINE__ returns the line number at which this expression appears in the file currently being parsed by the compiler.
__MODULE__ returns the module name of the file being parsed by the compiler.
val __POS__ : string * int * int * int__POS__ returns a tuple (file,lnum,cnum,enum), corresponding to the location at which this expression appears in the file currently being parsed by the compiler. file is the current filename, lnum the line number, cnum the character position in the line and enum the last character position in the line.
val __LOC_OF__ : 'a -> string * 'a__LOC_OF__ expr returns a pair (loc, expr) where loc is the location of expr in the file currently being parsed by the compiler, with the standard error format of OCaml: "File %S, line %d, characters %d-%d".
val __LINE_OF__ : 'a -> int * 'a__LINE_OF__ expr returns a pair (line, expr), where line is the line number at which the expression expr appears in the file currently being parsed by the compiler.
val __POS_OF__ : 'a -> (string * int * int * int) * 'a__POS_OF__ expr returns a pair (loc,expr), where loc is a tuple (file,lnum,cnum,enum) corresponding to the location at which the expression expr appears in the file currently being parsed by the compiler. file is the current filename, lnum the line number, cnum the character position in the line and enum the last character position in the line.
Composition operators
val (|>) : 'a -> ('a -> 'b) -> 'bReverse-application operator: x |> f |> g is exactly equivalent to g (f (x)). Left-associative operator, see Ocaml_operators for more information.
val (@@) : ('a -> 'b) -> 'a -> 'bApplication operator: g @@ f @@ x is exactly equivalent to g (f (x)). Right-associative operator, see Ocaml_operators for more information.
Integer arithmetic
Integers are Sys.int_size bits wide. All operations are taken modulo 2Sys.int_size. They do not fail on overflow.
Unary negation. You can also write - e instead of ~- e. Unary operator, see Ocaml_operators for more information.
Unary addition. You can also write + e instead of ~+ e. Unary operator, see Ocaml_operators for more information.
val (+) : int -> int -> intInteger addition. Left-associative operator, see Ocaml_operators for more information.
val (-) : int -> int -> intInteger subtraction. Left-associative operator, , see Ocaml_operators for more information.
val (*) : int -> int -> intInteger multiplication. Left-associative operator, see Ocaml_operators for more information.
val (/) : int -> int -> intInteger division. Raise Division_by_zero if the second argument is 0. Integer division rounds the real quotient of its arguments towards zero. More precisely, if x >= 0 and y > 0, x / y is the greatest integer less than or equal to the real quotient of x by y. Moreover, (- x) / y = x / (- y) = - (x / y). Left-associative operator, see Ocaml_operators for more information.
val (mod) : int -> int -> intInteger remainder. If y is not zero, the result of x mod y satisfies the following properties: x = (x / y) * y + x mod y and abs(x mod y) <= abs(y) - 1. If y = 0, x mod y raises Division_by_zero. Note that x mod y is negative only if x < 0. Raise Division_by_zero if y is zero. Left-associative operator, see Ocaml_operators for more information.
Return the absolute value of the argument. Note that this may be negative if the argument is min_int.
The greatest representable integer.
The smallest representable integer.
Bitwise operations
val (land) : int -> int -> intBitwise logical and. Left-associative operator, see Ocaml_operators for more information.
val (lor) : int -> int -> intBitwise logical or. Left-associative operator, see Ocaml_operators for more information.
val (lxor) : int -> int -> intBitwise logical exclusive or. Left-associative operator, see Ocaml_operators for more information.
Bitwise logical negation.
val (lsl) : int -> int -> intn lsl m shifts n to the left by m bits. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
val (lsr) : int -> int -> intn lsr m shifts n to the right by m bits. This is a logical shift: zeroes are inserted regardless of the sign of n. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
val (asr) : int -> int -> intn asr m shifts n to the right by m bits. This is an arithmetic shift: the sign bit of n is replicated. The result is unspecified if m < 0 or m > Sys.int_size. Right-associative operator, see Ocaml_operators for more information.
String operations
More string operations are provided in module String.
val (^) : string -> string -> stringString concatenation. Right-associative operator, see Ocaml_operators for more information.
Character operations
More character operations are provided in module Char.
val int_of_char : char -> intReturn the ASCII code of the argument.
val char_of_int : int -> charReturn the character with the given ASCII code. Raise Invalid_argument "char_of_int" if the argument is outside the range 0--255.
Unit operations
Discard the value of its argument and return (). For instance, ignore(f x) discards the result of the side-effecting function f. It is equivalent to f x; (), except that the latter may generate a compiler warning; writing ignore(f x) instead avoids the warning.
String conversion functions
val string_of_bool : bool -> stringReturn the string representation of a boolean. As the returned values may be shared, the user should not modify them directly.
val bool_of_string_opt : string -> bool optionConvert the given string to a boolean.
Return None if the string is not "true" or "false".
val string_of_int : int -> stringReturn the string representation of an integer, in decimal.
val int_of_string_opt : string -> int optionConvert the given string to an integer. The string is read in decimal (by default, or if the string begins with 0u), in hexadecimal (if it begins with 0x or 0X), in octal (if it begins with 0o or 0O), or in binary (if it begins with 0b or 0B).
The 0u prefix reads the input as an unsigned integer in the range [0, 2*max_int+1]. If the input exceeds max_int it is converted to the signed integer min_int + input - max_int - 1.
The _ (underscore) character can appear anywhere in the string and is ignored.
Return None if the given string is not a valid representation of an integer, or if the integer represented exceeds the range of integers representable in type int.
Pair operations
val fst : ('a * 'b) -> 'aReturn the first component of a pair.
val snd : ('a * 'b) -> 'bReturn the second component of a pair.
List operations
More list operations are provided in module List.
val (@) : 'a list -> 'a list -> 'a listList concatenation. Not tail-recursive (length of the first argument). Right-associative operator, see Ocaml_operators for more information.
References
type 'a ref = {mutable contents : 'a;
}The type of references (mutable indirection cells) containing a value of type 'a.
Return a fresh reference containing the given value.
!r returns the current contents of reference r. Equivalent to fun r -> r.contents. Unary operator, see Ocaml_operators for more information.
val (:=) : 'a ref -> 'a -> unitr := a stores the value of a in reference r. Equivalent to fun r v -> r.contents <- v. Right-associative operator, see Ocaml_operators for more information.
val incr : int ref -> unitIncrement the integer contained in the given reference. Equivalent to fun r -> r := succ !r.
val decr : int ref -> unitDecrement the integer contained in the given reference. Equivalent to fun r -> r := pred !r.
Result type
type ('a, 'b) result = ('a, 'b) Stdlib.result = | Ok of 'a| Error of 'b
Format strings are character strings with special lexical conventions that defines the functionality of formatted input/output functions. Format strings are used to read data with formatted input functions from module Scanf and to print data with formatted output functions from modules Printf and Format.
Format strings are made of three kinds of entities:
- conversions specifications, introduced by the special character
'%' followed by one or more characters specifying what kind of argument to read or print, - formatting indications, introduced by the special character
'@' followed by one or more characters specifying how to read or print the argument, - plain characters that are regular characters with usual lexical conventions. Plain characters specify string literals to be read in the input or printed in the output.
There is an additional lexical rule to escape the special characters '%' and '@' in format strings: if a special character follows a '%' character, it is treated as a plain character. In other words, "%%" is considered as a plain '%' and "%@" as a plain '@'.
For more information about conversion specifications and formatting indications available, read the documentation of modules Scanf, Printf and Format.
Format strings have a general and highly polymorphic type ('a, 'b, 'c, 'd, 'e, 'f) format6. The two simplified types, format and format4 below are included for backward compatibility with earlier releases of OCaml.
The meaning of format string type parameters is as follows:
'a is the type of the parameters of the format for formatted output functions (printf-style functions); 'a is the type of the values read by the format for formatted input functions (scanf-style functions).
'b is the type of input source for formatted input functions and the type of output target for formatted output functions. For printf-style functions from module Printf, 'b is typically out_channel; for printf-style functions from module Format, 'b is typically Format.formatter; for scanf-style functions from module Scanf, 'b is typically Scanf.Scanning.in_channel.
Type argument 'b is also the type of the first argument given to user's defined printing functions for %a and %t conversions, and user's defined reading functions for %r conversion.
'c is the type of the result of the %a and %t printing functions, and also the type of the argument transmitted to the first argument of kprintf-style functions or to the kscanf-style functions.
'd is the type of parameters for the scanf-style functions.
'e is the type of the receiver function for the scanf-style functions.
'f is the final result type of a formatted input/output function invocation: for the printf-style functions, it is typically unit; for the scanf-style functions, it is typically the result type of the receiver function.
Converts a format string into a string.
format_of_string s returns a format string read from the string literal s. Note: format_of_string can not convert a string argument that is not a literal. If you need this functionality, use the more general Scanf.format_from_string function.
val (^^) :
('a, 'b, 'c, 'd, 'e, 'f) format6 ->
('f, 'b, 'c, 'e, 'g, 'h) format6 ->
('a, 'b, 'c, 'd, 'g, 'h) format6f1 ^^ f2 catenates format strings f1 and f2. The result is a format string that behaves as the concatenation of format strings f1 and f2: in case of formatted output, it accepts arguments from f1, then arguments from f2; in case of formatted input, it returns results from f1, then results from f2. Right-associative operator, see Ocaml_operators for more information.