1Pervasives(3) OCaml library Pervasives(3)
2
6 Pervasives - The initially opened module.
7
9 Module Pervasives
10
12 Module Pervasives
13 : sig end
14 The initially opened module.
17 This module provides the basic operations over the built-in types (num‐
19 bers, booleans, strings, exceptions, references, lists, arrays, input-
20 output channels, ...)
21 This module is automatically opened at the beginning of each compila‐
23 tion. All components of this module can therefore be referred by their
24 short name, without prefixing them by Pervasives .
25 === Exceptions ===
34 val raise : exn -> 'a
37 Raise the given exception value
39 val invalid_arg : string -> 'a
44 Raise exception Invalid_argument with the given string.
46 val failwith : string -> 'a
51 Raise exception Failure with the given string.
53 exception Exit
58 The Exit exception is not raised by any library function. It is pro‐
61 vided for use in your programs.
62 === Comparisons ===
68 val (=) : 'a -> 'a -> bool
71 e1 = e2 tests for structural equality of e1 and e2 . Mutable struc‐
74 tures (e.g. references and arrays) are equal if and only if their cur‐
75 rent contents are structurally equal, even if the two mutable objects
76 are not the same physical object. Equality between functional values
77 raises Invalid_argument . Equality between cyclic data structures does
78 not terminate.
79 val (<>) : 'a -> 'a -> bool
84 Negation of Pervasives.(=) .
86 val (<) : 'a -> 'a -> bool
91 See Pervasives.(>=) .
93 val (>) : 'a -> 'a -> bool
98 See Pervasives.(>=) .
100 val (<=) : 'a -> 'a -> bool
105 See Pervasives.(>=) .
107 val (>=) : 'a -> 'a -> bool
112 Structural ordering functions. These functions coincide with the usual
114 orderings over integers, characters, strings and floating-point num‐
115 bers, and extend them to a total ordering over all types. The ordering
116 is compatible with (=) . As in the case of (=) , mutable structures are
117 compared by contents. Comparison between functional values raises
118 Invalid_argument . Comparison between cyclic structures does not ter‐
119 minate.
120 val compare : 'a -> 'a -> int
125 compare x y returns 0 if x is equal to y , a negative integer if x is
128 less than y , and a positive integer if x is greater than y . The
129 ordering implemented by compare is compatible with the comparison pred‐
130 icates = , < and > defined above, with one difference on the treatment
131 of the float value Pervasives.nan . Namely, the comparison predicates
132 treat nan as different from any other float value, including itself;
133 while compare treats nan as equal to itself and less than any other
134 float value. This treatment of nan ensures that compare defines a
135 total ordering relation.
136 compare applied to functional values may raise Invalid_argument . com‐
139 pare applied to cyclic structures may not terminate.
140 The compare function can be used as the comparison function required by
142 the Set.Make and Map.Make functors, as well as the List.sort and
143 Array.sort functions.
144 val min : 'a -> 'a -> 'a
149 Return the smaller of the two arguments.
151 val max : 'a -> 'a -> 'a
156 Return the greater of the two arguments.
158 val (==) : 'a -> 'a -> bool
163 e1 == e2 tests for physical equality of e1 and e2 . On integers and
166 characters, physical equality is identical to structural equality. On
167 mutable structures, e1 == e2 is true if and only if physical modifica‐
168 tion of e1 also affects e2 . On non-mutable structures, the behavior
169 of (==) is implementation-dependent; however, it is guaranteed that e1
170 == e2 implies compare e1 e2 = 0 .
171 val (!=) : 'a -> 'a -> bool
176 Negation of Pervasives.(==) .
178 === Boolean operations ===
184 val not : bool -> bool
187 The boolean negation.
189 val (&&) : bool -> bool -> bool
194 The boolean ``and''. Evaluation is sequential, left-to-right: in e1 &&
196 e2 , e1 is evaluated first, and if it returns false , e2 is not evalu‐
197 ated at all.
198 val (&) : bool -> bool -> bool
203 Deprecated.
205 Pervasives.(&&) should be used instead.
207 val (||) : bool -> bool -> bool
212 The boolean ``or''. Evaluation is sequential, left-to-right: in e1 ||
214 e2 , e1 is evaluated first, and if it returns true , e2 is not evalu‐
215 ated at all.
216 val or : bool -> bool -> bool
221 Deprecated.
223 Pervasives.(||) should be used instead.
225 === Integer arithmetic ===
231 === Integers are 31 bits wide (or 63 bits on 64-bit processors). All
235 operations are taken modulo 2^{31} (or 2^{63}). They do not fail on
236 overflow. ===
237 val (~-) : int -> int
240 Unary negation. You can also write -e instead of ~-e .
242 val succ : int -> int
247 succ x is x+1 .
250 val pred : int -> int
255 pred x is x-1 .
258 val (+) : int -> int -> int
263 Integer addition.
265 val (-) : int -> int -> int
270 Integer subtraction.
272 val (*) : int -> int -> int
277 Integer multiplication.
279 val (/) : int -> int -> int
284 Integer division. Raise Division_by_zero if the second argument is 0.
286 Integer division rounds the real quotient of its arguments towards
287 zero. More precisely, if x >= 0 and y > 0 , x / y is the greatest
288 integer less than or equal to the real quotient of x by y . Moreover,
289 (-x) / y = x / (-y) = -(x / y) .
290 val mod : int -> int -> int
295 Integer remainder. If y is not zero, the result of x mod y satisfies
297 the following properties: x = (x / y) * y + x mod y and abs(x mod y) <=
298 abs(y)-1 . If y = 0 , x mod y raises Division_by_zero . Notice that x
299 mod y is nonpositive if and only if x < 0 . Raise Division_by_zero if
300 y is zero.
301 val abs : int -> int
306 Return the absolute value of the argument. Note that this may be nega‐
308 tive if the argument is min_int .
309 val max_int : int
314 The greatest representable integer.
316 val min_int : int
321 The smallest representable integer.
323 === Bitwise operations ===
329 val land : int -> int -> int
332 Bitwise logical and.
334 val lor : int -> int -> int
339 Bitwise logical or.
341 val lxor : int -> int -> int
346 Bitwise logical exclusive or.
348 val lnot : int -> int
353 Bitwise logical negation.
355 val lsl : int -> int -> int
360 n lsl m shifts n to the left by m bits. The result is unspecified if m
363 < 0 or m >= bitsize , where bitsize is 32 on a 32-bit platform and 64
364 on a 64-bit platform.
365 val lsr : int -> int -> int
370 n lsr m shifts n to the right by m bits. This is a logical shift:
373 zeroes are inserted regardless of the sign of n . The result is
374 unspecified if m < 0 or m >= bitsize .
375 val asr : int -> int -> int
380 n asr m shifts n to the right by m bits. This is an arithmetic shift:
383 the sign bit of n is replicated. The result is unspecified if m < 0 or
384 m >= bitsize .
385 === Floating-point arithmetic Caml's floating-point numbers follow the
391 IEEE 754 standard, using double precision (64 bits) numbers. Floating-
392 point operations never raise an exception on overflow, underflow, divi‐
393 sion by zero, etc. Instead, special IEEE numbers are returned as appro‐
394 priate, such as infinity for 1.0 /. 0.0, neg_infinity for -1.0 /. 0.0,
395 and nan (``not a number'') for 0.0 /. 0.0. These special numbers then
396 propagate through floating-point computations as expected: for
397 instance, 1.0 /. infinity is 0.0, and any operation with nan as argu‐
398 ment returns nan as result. ===
399 val (~-.) : float -> float
402 Unary negation. You can also write -.e instead of ~-.e .
404 val (+.) : float -> float -> float
409 Floating-point addition
411 val (-.) : float -> float -> float
416 Floating-point subtraction
418 val (*.) : float -> float -> float
423 Floating-point multiplication
425 val (/.) : float -> float -> float
430 Floating-point division.
432 val (**) : float -> float -> float
437 Exponentiation
439 val sqrt : float -> float
444 Square root
446 val exp : float -> float
451 Exponential.
453 val log : float -> float
458 Natural logarithm.
460 val log10 : float -> float
465 Base 10 logarithm.
467 val cos : float -> float
472 See Pervasives.atan2 .
474 val sin : float -> float
479 See Pervasives.atan2 .
481 val tan : float -> float
486 See Pervasives.atan2 .
488 val acos : float -> float
493 See Pervasives.atan2 .
495 val asin : float -> float
500 See Pervasives.atan2 .
502 val atan : float -> float
507 See Pervasives.atan2 .
509 val atan2 : float -> float -> float
514 The usual trigonometric functions.
516 val cosh : float -> float
521 See Pervasives.tanh .
523 val sinh : float -> float
528 See Pervasives.tanh .
530 val tanh : float -> float
535 The usual hyperbolic trigonometric functions.
537 val ceil : float -> float
542 See Pervasives.floor .
544 val floor : float -> float
549 Round the given float to an integer value. floor f returns the great‐
551 est integer value less than or equal to f . ceil f returns the least
552 integer value greater than or equal to f .
553 val abs_float : float -> float
558 Return the absolute value of the argument.
560 val mod_float : float -> float -> float
565 mod_float a b returns the remainder of a with respect to b . The
568 returned value is a -. n *. b , where n is the quotient a /. b rounded
569 towards zero to an integer.
570 val frexp : float -> float * int
575 frexp f returns the pair of the significant and the exponent of f .
578 When f is zero, the significant x and the exponent n of f are equal to
579 zero. When f is non-zero, they are defined by f = x *. 2 ** n and 0.5
580 <= x < 1.0 .
581 val ldexp : float -> int -> float
586 ldexp x n returns x *. 2 ** n .
589 val modf : float -> float * float
594 modf f returns the pair of the fractional and integral part of f .
597 val float : int -> float
602 Same as Pervasives.float_of_int .
604 val float_of_int : int -> float
609 Convert an integer to floating-point.
611 val truncate : float -> int
616 Same as Pervasives.int_of_float .
618 val int_of_float : float -> int
623 Truncate the given floating-point number to an integer. The result is
625 unspecified if it falls outside the range of representable integers.
626 val infinity : float
631 Positive infinity.
633 val neg_infinity : float
638 Negative infinity.
640 val nan : float
645 A special floating-point value denoting the result of an undefined
647 operation such as 0.0 /. 0.0 . Stands for ``not a number''. Any
648 floating-point operation with nan as argument returns nan as result.
649 As for floating-point comparisons, = , < , <= , > and >= return false
650 and <> returns true if one or both of their arguments is nan .
651 val max_float : float
656 The largest positive finite value of type float .
658 val min_float : float
663 The smallest positive, non-zero, non-denormalized value of type float .
665 val epsilon_float : float
670 The smallest positive float x such that 1.0 +. x <> 1.0 .
672 type fpclass =
676 | FP_normal (* Normal number, none of the below *)
677 | FP_subnormal (* Number very close to 0.0, has reduced precision *)
678 | FP_zero (* Number is 0.0 or -0.0 *)
679 | FP_infinite (* Number is positive or negative infinity *)
680 | FP_nan (* Not a number: result of an undefined operation *)
681 The five classes of floating-point numbers, as determined by the Perva‐
684 sives.classify_float function.
685 val classify_float : float -> fpclass
690 Return the class of the given floating-point number: normal, subnormal,
692 zero, infinite, or not a number.
693 === String operations More string operations are provided in module
699 String. ===
700 val (^) : string -> string -> string
703 String concatenation.
705 === Character operations More character operations are provided in mod‐
711 ule Char. ===
712 val int_of_char : char -> int
715 Return the ASCII code of the argument.
717 val char_of_int : int -> char
722 Return the character with the given ASCII code. Raise Invalid_argument
724 char_of_int if the argument is outside the range 0--255.
725 === Unit operations ===
731 val ignore : 'a -> unit
734 Discard the value of its argument and return () . For instance,
736 ignore(f x) discards the result of the side-effecting function f . It
737 is equivalent to f x; () , except that the latter may generate a com‐
738 piler warning; writing ignore(f x) instead avoids the warning.
739 === String conversion functions ===
745 val string_of_bool : bool -> string
748 Return the string representation of a boolean.
750 val bool_of_string : string -> bool
755 Convert the given string to a boolean. Raise Invalid_argument
757 bool_of_string if the string is not true or false .
758 val string_of_int : int -> string
763 Return the string representation of an integer, in decimal.
765 val int_of_string : string -> int
770 Convert the given string to an integer. The string is read in decimal
772 (by default) or in hexadecimal (if it begins with 0x or 0X ), octal (if
773 it begins with 0o or 0O ), or binary (if it begins with 0b or 0B ).
774 Raise Failure int_of_string if the given string is not a valid repre‐
775 sentation of an integer, or if the integer represented exceeds the
776 range of integers representable in type int .
777 val string_of_float : float -> string
782 Return the string representation of a floating-point number.
784 val float_of_string : string -> float
789 Convert the given string to a float. Raise Failure float_of_string if
791 the given string is not a valid representation of a float.
792 === Pair operations ===
798 val fst : 'a * 'b -> 'a
801 Return the first component of a pair.
803 val snd : 'a * 'b -> 'b
808 Return the second component of a pair.
810 === List operations More list operations are provided in module List.
816 ===
817 val (@) : 'a list -> 'a list -> 'a list
820 List concatenation.
822 === Input/output ===
828 type in_channel
830 The type of input channel.
833 type out_channel
837 The type of output channel.
840 val stdin : in_channel
845 The standard input for the process.
847 val stdout : out_channel
852 The standard output for the process.
854 val stderr : out_channel
859 The standard error ouput for the process.
861 === Output functions on standard output ===
867 val print_char : char -> unit
870 Print a character on standard output.
872 val print_string : string -> unit
877 Print a string on standard output.
879 val print_int : int -> unit
884 Print an integer, in decimal, on standard output.
886 val print_float : float -> unit
891 Print a floating-point number, in decimal, on standard output.
893 val print_endline : string -> unit
898 Print a string, followed by a newline character, on standard output and
900 flush standard output.
901 val print_newline : unit -> unit
906 Print a newline character on standard output, and flush standard out‐
908 put. This can be used to simulate line buffering of standard output.
909 === Output functions on standard error ===
915 val prerr_char : char -> unit
918 Print a character on standard error.
920 val prerr_string : string -> unit
925 Print a string on standard error.
927 val prerr_int : int -> unit
932 Print an integer, in decimal, on standard error.
934 val prerr_float : float -> unit
939 Print a floating-point number, in decimal, on standard error.
941 val prerr_endline : string -> unit
946 Print a string, followed by a newline character on standard error and
948 flush standard error.
949 val prerr_newline : unit -> unit
954 Print a newline character on standard error, and flush standard error.
956 === Input functions on standard input ===
962 val read_line : unit -> string
965 Flush standard output, then read characters from standard input until a
967 newline character is encountered. Return the string of all characters
968 read, without the newline character at the end.
969 val read_int : unit -> int
974 Flush standard output, then read one line from standard input and con‐
976 vert it to an integer. Raise Failure int_of_string if the line read is
977 not a valid representation of an integer.
978 val read_float : unit -> float
983 Flush standard output, then read one line from standard input and con‐
985 vert it to a floating-point number. The result is unspecified if the
986 line read is not a valid representation of a floating-point number.
987 === General output functions ===
993 type open_flag =
995 | Open_rdonly (* open for reading. *)
996 | Open_wronly (* open for writing. *)
997 | Open_append (* open for appending: always write at end of file. *)
998 | Open_creat (* create the file if it does not exist. *)
999 | Open_trunc (* empty the file if it already exists. *)
1000 | Open_excl (* fail if Open_creat and the file already exists. *)
1001 | Open_binary (* open in binary mode (no conversion). *)
1002 | Open_text (* open in text mode (may perform conversions). *)
1003 | Open_nonblock (* open in non-blocking mode. *)
1004 Opening modes for Pervasives.open_out_gen and Pervasives.open_in_gen .
1007 val open_out : string -> out_channel
1012 Open the named file for writing, and return a new output channel on
1014 that file, positionned at the beginning of the file. The file is trun‐
1015 cated to zero length if it already exists. It is created if it does not
1016 already exists. Raise Sys_error if the file could not be opened.
1017 val open_out_bin : string -> out_channel
1022 Same as Pervasives.open_out , but the file is opened in binary mode, so
1024 that no translation takes place during writes. On operating systems
1025 that do not distinguish between text mode and binary mode, this func‐
1026 tion behaves like Pervasives.open_out .
1027 val open_out_gen : open_flag list -> int -> string -> out_channel
1032 open_out_gen mode perm filename opens the named file for writing, as
1035 described above. The extra argument mode specify the opening mode. The
1036 extra argument perm specifies the file permissions, in case the file
1037 must be created. Pervasives.open_out and Pervasives.open_out_bin are
1038 special cases of this function.
1039 val flush : out_channel -> unit
1044 Flush the buffer associated with the given output channel, performing
1046 all pending writes on that channel. Interactive programs must be care‐
1047 ful about flushing standard output and standard error at the right
1048 time.
1049 val flush_all : unit -> unit
1054 Flush all open output channels; ignore errors.
1056 val output_char : out_channel -> char -> unit
1061 Write the character on the given output channel.
1063 val output_string : out_channel -> string -> unit
1068 Write the string on the given output channel.
1070 val output : out_channel -> string -> int -> int -> unit
1075 output oc buf pos len writes len characters from string buf , starting
1078 at offset pos , to the given output channel oc . Raise Invalid_argu‐
1079 ment output if pos and len do not designate a valid substring of buf .
1080 val output_byte : out_channel -> int -> unit
1085 Write one 8-bit integer (as the single character with that code) on the
1087 given output channel. The given integer is taken modulo 256.
1088 val output_binary_int : out_channel -> int -> unit
1093 Write one integer in binary format (4 bytes, big-endian) on the given
1095 output channel. The given integer is taken modulo 2^{32. The only
1096 reliable way to read it back is through the Pervasives.input_binary_int
1097 function. The format is compatible across all machines for a given ver‐
1098 sion of Objective Caml.
1099 val output_value : out_channel -> 'a -> unit
1104 Write the representation of a structured value of any type to a chan‐
1106 nel. Circularities and sharing inside the value are detected and pre‐
1107 served. The object can be read back, by the function Perva‐
1108 sives.input_value . See the description of module Marshal for more
1109 information. Pervasives.output_value is equivalent to Marshal.to_chan‐
1110 nel with an empty list of flags.
1111 val seek_out : out_channel -> int -> unit
1116 seek_out chan pos sets the current writing position to pos for channel
1119 chan . This works only for regular files. On files of other kinds (such
1120 as terminals, pipes and sockets), the behavior is unspecified.
1121 val pos_out : out_channel -> int
1126 Return the current writing position for the given channel. Does not
1128 work on channels opened with the Open_append flag (returns unspecified
1129 results).
1130 val out_channel_length : out_channel -> int
1135 Return the size (number of characters) of the regular file on which the
1137 given channel is opened. If the channel is opened on a file that is
1138 not a regular file, the result is meaningless.
1139 val close_out : out_channel -> unit
1144 Close the given channel, flushing all buffered write operations. Out‐
1146 put functions raise a Sys_error exception when they are applied to a
1147 closed output channel, except close_out and flush , which do nothing
1148 when applied to an already closed channel. Note that close_out may
1149 raise Sys_error if the operating system signals an error when flushing
1150 or closing.
1151 val close_out_noerr : out_channel -> unit
1156 Same as close_out , but ignore all errors.
1158 val set_binary_mode_out : out_channel -> bool -> unit
1163 set_binary_mode_out oc true sets the channel oc to binary mode: no
1166 translations take place during output. set_binary_mode_out oc false
1167 sets the channel oc to text mode: depending on the operating system,
1168 some translations may take place during output. For instance, under
1169 Windows, end-of-lines will be translated from \n to \r\n . This func‐
1170 tion has no effect under operating systems that do not distinguish
1171 between text mode and binary mode.
1172 === General input functions ===
1178 val open_in : string -> in_channel
1181 Open the named file for reading, and return a new input channel on that
1183 file, positionned at the beginning of the file. Raise Sys_error if the
1184 file could not be opened.
1185 val open_in_bin : string -> in_channel
1190 Same as Pervasives.open_in , but the file is opened in binary mode, so
1192 that no translation takes place during reads. On operating systems that
1193 do not distinguish between text mode and binary mode, this function
1194 behaves like Pervasives.open_in .
1195 val open_in_gen : open_flag list -> int -> string -> in_channel
1200 open_in mode perm filename opens the named file for reading, as
1203 described above. The extra arguments mode and perm specify the opening
1204 mode and file permissions. Pervasives.open_in and Perva‐
1205 sives.open_in_bin are special cases of this function.
1206 val input_char : in_channel -> char
1211 Read one character from the given input channel. Raise End_of_file if
1213 there are no more characters to read.
1214 val input_line : in_channel -> string
1219 Read characters from the given input channel, until a newline character
1221 is encountered. Return the string of all characters read, without the
1222 newline character at the end. Raise End_of_file if the end of the file
1223 is reached at the beginning of line.
1224 val input : in_channel -> string -> int -> int -> int
1229 input ic buf pos len reads up to len characters from the given channel
1232 ic , storing them in string buf , starting at character number pos .
1233 It returns the actual number of characters read, between 0 and len
1234 (inclusive). A return value of 0 means that the end of file was
1235 reached. A return value between 0 and len exclusive means that not all
1236 requested len characters were read, either because no more characters
1237 were available at that time, or because the implementation found it
1238 convenient to do a partial read; input must be called again to read the
1239 remaining characters, if desired. (See also Pervasives.really_input
1240 for reading exactly len characters.) Exception Invalid_argument input
1241 is raised if pos and len do not designate a valid substring of buf .
1242 val really_input : in_channel -> string -> int -> int -> unit
1247 really_input ic buf pos len reads len characters from channel ic ,
1250 storing them in string buf , starting at character number pos . Raise
1251 End_of_file if the end of file is reached before len characters have
1252 been read. Raise Invalid_argument really_input if pos and len do not
1253 designate a valid substring of buf .
1254 val input_byte : in_channel -> int
1259 Same as Pervasives.input_char , but return the 8-bit integer represent‐
1261 ing the character. Raise End_of_file if an end of file was reached.
1262 val input_binary_int : in_channel -> int
1267 Read an integer encoded in binary format (4 bytes, big-endian) from the
1269 given input channel. See Pervasives.output_binary_int . Raise
1270 End_of_file if an end of file was reached while reading the integer.
1271 val input_value : in_channel -> 'a
1276 Read the representation of a structured value, as produced by Perva‐
1278 sives.output_value , and return the corresponding value. This function
1279 is identical to Marshal.from_channel ; see the description of module
1280 Marshal for more information, in particular concerning the lack of type
1281 safety.
1282 val seek_in : in_channel -> int -> unit
1287 seek_in chan pos sets the current reading position to pos for channel
1290 chan . This works only for regular files. On files of other kinds, the
1291 behavior is unspecified.
1292 val pos_in : in_channel -> int
1297 Return the current reading position for the given channel.
1299 val in_channel_length : in_channel -> int
1304 Return the size (number of characters) of the regular file on which the
1306 given channel is opened. If the channel is opened on a file that is
1307 not a regular file, the result is meaningless. The returned size does
1308 not take into account the end-of-line translations that can be per‐
1309 formed when reading from a channel opened in text mode.
1310 val close_in : in_channel -> unit
1315 Close the given channel. Input functions raise a Sys_error exception
1317 when they are applied to a closed input channel, except close_in ,
1318 which does nothing when applied to an already closed channel. Note
1319 that close_in may raise Sys_error if the operating system signals an
1320 error.
1321 val close_in_noerr : in_channel -> unit
1326 Same as close_in , but ignore all errors.
1328 val set_binary_mode_in : in_channel -> bool -> unit
1333 set_binary_mode_in ic true sets the channel ic to binary mode: no
1336 translations take place during input. set_binary_mode_out ic false
1337 sets the channel ic to text mode: depending on the operating system,
1338 some translations may take place during input. For instance, under
1339 Windows, end-of-lines will be translated from \r\n to \n . This func‐
1340 tion has no effect under operating systems that do not distinguish
1341 between text mode and binary mode.
1342 === Operations on large files ===
1348 module LargeFile : sig end
1350 Operations on large files. This sub-module provides 64-bit variants of
1353 the channel functions that manipulate file positions and file sizes.
1354 By representing positions and sizes by 64-bit integers (type int64 )
1355 instead of regular integers (type int ), these alternate functions
1356 allow operating on files whose sizes are greater than max_int .
1357 === References ===
1363 type 'a ref = {
1365 mutable contents : 'a ;
1367 }
1368 The type of references (mutable indirection cells) containing a value
1371 of type 'a .
1372 val ref : 'a -> 'a ref
1377 Return a fresh reference containing the given value.
1379 val (!) : 'a ref -> 'a
1384 !r returns the current contents of reference r . Equivalent to fun r
1387 -> r.contents .
1388 val (:=) : 'a ref -> 'a -> unit
1393 r := a stores the value of a in reference r . Equivalent to fun r v ->
1396 r.contents <- v .
1397 val incr : int ref -> unit
1402 Increment the integer contained in the given reference. Equivalent to
1404 fun r -> r := succ !r .
1405 val decr : int ref -> unit
1410 Decrement the integer contained in the given reference. Equivalent to
1412 fun r -> r := pred !r .
1413 === Operations on format strings ===
1419 === See modules Printf and Scanf for more operations on format strings.
1423 ===
1424 type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
1426 Simplified type for format strings, included for backward compatibility
1429 with earlier releases of Objective Caml. 'a is the type of the parame‐
1430 ters of the format, 'c is the result type for the "printf"-style func‐
1431 tion, and 'b is the type of the first argument given to %a and %t
1432 printing functions.
1433 val string_of_format : ('a, 'b, 'c, 'd) format4 -> string
1438 Converts a format string into a string.
1440 val format_of_string : ('a, 'b, 'c, 'd) format4 -> ('a, 'b, 'c, 'd)
1445 format4
1446 format_of_string s returns a format string read from the string literal
1449 s .
1450 val (^^) : ('a, 'b, 'c, 'd) format4 -> ('d, 'b, 'c, 'e) format4 -> ('a,
1455 'b, 'c, 'e) format4
1456 f1 ^^ f2 catenates formats f1 and f2 . The result is a format that
1459 accepts arguments from f1 , then arguments from f2 .
1460 === Program termination ===
1466 val exit : int -> 'a
1469 Terminate the process, returning the given status code to the operating
1471 system: usually 0 to indicate no errors, and a small positive integer
1472 to indicate failure. All open output channels are flushed with
1473 flush_all. An implicit exit 0 is performed each time a program termi‐
1474 nates normally. An implicit exit 2 is performed if the program termi‐
1475 nates early because of an uncaught exception.
1476 val at_exit : (unit -> unit) -> unit
1481 Register the given function to be called at program termination time.
1483 The functions registered with at_exit will be called when the program
1484 executes Pervasives.exit , or terminates, either normally or because of
1485 an uncaught exception. The functions are called in ``last in, first
1486 out'' order: the function most recently added with at_exit is called
1487 first.
1488OCamldoc 2007-05-24 Pervasives(3)