1Stdlib(3)                        OCaml library                       Stdlib(3)
2
3
4

NAME

6       Stdlib - The OCaml Standard library.
7

Module

9       Module   Stdlib
10

Documentation

12       Module Stdlib
13        : sig end
14
15
16       The OCaml Standard library.
17
18       This  module  is automatically opened at the beginning of each compila‐
19       tion. All components of this module can therefore be referred by  their
20       short name, without prefixing them by Stdlib .
21
22       It particular, it provides the basic operations over the built-in types
23       (numbers, booleans, byte sequences,  strings,  exceptions,  references,
24       lists, arrays, input-output channels, ...) and the modules .
25
26
27
28
29
30
31
32   Exceptions
33       val raise : exn -> 'a
34
35       Raise the given exception value
36
37
38
39       val raise_notrace : exn -> 'a
40
41       A faster version raise which does not record the backtrace.
42
43
44       Since 4.02.0
45
46
47
48       val invalid_arg : string -> 'a
49
50       Raise exception Invalid_argument with the given string.
51
52
53
54       val failwith : string -> 'a
55
56       Raise exception Failure with the given string.
57
58
59
60       exception Exit
61
62
63       The  Exit  exception is not raised by any library function.  It is pro‐
64       vided for use in your programs.
65
66
67
68       exception Match_failure of (string * int * int)
69
70
71       Exception raised when none of the cases of  a  pattern-matching  apply.
72       The  arguments are the location of the match keyword in the source code
73       (file name, line number, column number).
74
75
76
77       exception Assert_failure of (string * int * int)
78
79
80       Exception raised when an assertion fails. The arguments are  the  loca‐
81       tion  of the assert keyword in the source code (file name, line number,
82       column number).
83
84
85
86       exception Invalid_argument of string
87
88
89       Exception raised by library functions to signal that  the  given  argu‐
90       ments  do not make sense. The string gives some information to the pro‐
91       grammer. As a general rule, this exception should not be caught, it de‐
92       notes  a programming error and the code should be modified not to trig‐
93       ger it.
94
95
96
97       exception Failure of string
98
99
100       Exception raised by library functions to signal that they are undefined
101       on the given arguments. The string is meant to give some information to
102       the programmer; you must not pattern match on the  string  literal  be‐
103       cause it may change in future versions (use Failure _ instead).
104
105
106
107       exception Not_found
108
109
110       Exception  raised by search functions when the desired object could not
111       be found.
112
113
114
115       exception Out_of_memory
116
117
118       Exception raised by the garbage collector when  there  is  insufficient
119       memory  to  complete  the computation. (Not reliable for allocations on
120       the minor heap.)
121
122
123
124       exception Stack_overflow
125
126
127       Exception raised by the bytecode interpreter when the evaluation  stack
128       reaches  its maximal size. This often indicates infinite or excessively
129       deep recursion in the user's program.
130
131       Before 4.10, it was not fully implemented by the native-code compiler.
132
133
134
135       exception Sys_error of string
136
137
138       Exception raised by the input/output functions to report  an  operating
139       system  error. The string is meant to give some information to the pro‐
140       grammer; you must not pattern match on the string  literal  because  it
141       may change in future versions (use Sys_error _ instead).
142
143
144
145       exception End_of_file
146
147
148       Exception  raised by input functions to signal that the end of file has
149       been reached.
150
151
152
153       exception Division_by_zero
154
155
156       Exception raised by integer  division  and  remainder  operations  when
157       their second argument is zero.
158
159
160
161       exception Sys_blocked_io
162
163
164       A  special  case  of  Sys_error  raised  when  no  I/O is possible on a
165       non-blocking I/O channel.
166
167
168
169       exception Undefined_recursive_module of (string * int * int)
170
171
172       Exception raised when an ill-founded  recursive  module  definition  is
173       evaluated.  The  arguments  are  the  location of the definition in the
174       source code (file name, line number, column number).
175
176
177
178
179   Comparisons
180       val (=) : 'a -> 'a -> bool
181
182
183       e1 = e2 tests for structural equality of e1 and e2  .   Mutable  struc‐
184       tures  (e.g. references and arrays) are equal if and only if their cur‐
185       rent contents are structurally equal, even if the two  mutable  objects
186       are  not  the same physical object.  Equality between functional values
187       raises Invalid_argument .  Equality between cyclic data structures  may
188       not terminate.  Left-associative operator, see Ocaml_operators for more
189       information.
190
191
192
193       val (<>) : 'a -> 'a -> bool
194
195       Negation of (=) .  Left-associative operator, see  Ocaml_operators  for
196       more information.
197
198
199
200       val (<) : 'a -> 'a -> bool
201
202       See (>=) .  Left-associative operator, see Ocaml_operators for more in‐
203       formation.
204
205
206
207       val (>) : 'a -> 'a -> bool
208
209       See (>=) .  Left-associative operator,  see  Ocaml_operators  for  more
210       information.
211
212
213
214       val (<=) : 'a -> 'a -> bool
215
216       See  (>=)  .   Left-associative operator,  see Ocaml_operators for more
217       information.
218
219
220
221       val (>=) : 'a -> 'a -> bool
222
223       Structural ordering functions. These functions coincide with the  usual
224       orderings over integers, characters, strings, byte sequences and float‐
225       ing-point numbers, and extend them to a total ordering over all  types.
226       The ordering is compatible with ( = ) . As in the case of ( = ) , muta‐
227       ble structures are compared by contents.  Comparison between functional
228       values  raises Invalid_argument .  Comparison between cyclic structures
229       may not terminate.  Left-associative operator, see Ocaml_operators  for
230       more information.
231
232
233
234       val compare : 'a -> 'a -> int
235
236
237       compare  x  y returns 0 if x is equal to y , a negative integer if x is
238       less than y , and a positive integer if x is greater than y .  The  or‐
239       dering  implemented by compare is compatible with the comparison predi‐
240       cates = , < and > defined above,  with one difference on the  treatment
241       of  the  float value nan .  Namely, the comparison predicates treat nan
242       as different from any other float value, including itself;  while  com‐
243       pare treats nan as equal to itself and less than any other float value.
244       This treatment of nan ensures that compare defines a total ordering re‐
245       lation.
246
247
248       compare applied to functional values may raise Invalid_argument .  com‐
249       pare applied to cyclic structures may not terminate.
250
251       The compare function can be used as the comparison function required by
252       the  Set.Make  and  Map.Make functors, as well as the List.sort and Ar‐
253       ray.sort functions.
254
255
256
257       val min : 'a -> 'a -> 'a
258
259       Return the smaller of the two arguments.  The result is unspecified  if
260       one of the arguments contains the float value nan .
261
262
263
264       val max : 'a -> 'a -> 'a
265
266       Return  the greater of the two arguments.  The result is unspecified if
267       one of the arguments contains the float value nan .
268
269
270
271       val (==) : 'a -> 'a -> bool
272
273
274       e1 == e2 tests for physical equality of e1 and e2 .  On  mutable  types
275       such as references, arrays, byte sequences, records with mutable fields
276       and objects with mutable instance variables, e1 == e2 is  true  if  and
277       only  if  physical modification of e1 also affects e2 .  On non-mutable
278       types, the behavior of ( == ) is implementation-dependent; however,  it
279       is  guaranteed that e1 == e2 implies compare e1 e2 = 0 .  Left-associa‐
280       tive operator,  see Ocaml_operators for more information.
281
282
283
284       val (!=) : 'a -> 'a -> bool
285
286       Negation of (==) .  Left-associative operator,  see Ocaml_operators for
287       more information.
288
289
290
291
292   Boolean operations
293       val not : bool -> bool
294
295       The boolean negation.
296
297
298
299       val (&&) : bool -> bool -> bool
300
301       The boolean 'and'. Evaluation is sequential, left-to-right: in e1 && e2
302       , e1 is evaluated first, and if it returns false , e2 is not  evaluated
303       at  all.  Right-associative operator,  see Ocaml_operators for more in‐
304       formation.
305
306
307
308       val (&) : bool -> bool -> bool
309
310       Deprecated.
311
312       (&&) should be used instead.  Right-associative operator, see Ocaml_op‐
313       erators for more information.
314
315
316
317       val (||) : bool -> bool -> bool
318
319       The  boolean 'or'. Evaluation is sequential, left-to-right: in e1 || e2
320       , e1 is evaluated first, and if it returns true , e2 is  not  evaluated
321       at  all.  Right-associative operator,  see Ocaml_operators for more in‐
322       formation.
323
324
325
326       val (or) : bool -> bool -> bool
327
328       Deprecated.
329
330       (||) should be used instead.  Right-associative operator, see Ocaml_op‐
331       erators for more information.
332
333
334
335
336   Debugging
337       val __LOC__ : string
338
339
340       __LOC__  returns  the  location at which this expression appears in the
341       file currently being parsed by the compiler, with  the  standard  error
342       format of OCaml: "File %S, line %d, characters %d-%d".
343
344
345       Since 4.02.0
346
347
348
349       val __FILE__ : string
350
351
352       __FILE__  returns  the  name  of the file currently being parsed by the
353       compiler.
354
355
356       Since 4.02.0
357
358
359
360       val __LINE__ : int
361
362
363       __LINE__ returns the line number at which this  expression  appears  in
364       the file currently being parsed by the compiler.
365
366
367       Since 4.02.0
368
369
370
371       val __MODULE__ : string
372
373
374       __MODULE__ returns the module name of the file being parsed by the com‐
375       piler.
376
377
378       Since 4.02.0
379
380
381
382       val __POS__ : string * int * int * int
383
384
385       __POS__ returns a tuple (file,lnum,cnum,enum) ,  corresponding  to  the
386       location  at  which this expression appears in the file currently being
387       parsed by the compiler.  file is the current filename,  lnum  the  line
388       number, cnum the character position in the line and enum the last char‐
389       acter position in the line.
390
391
392       Since 4.02.0
393
394
395
396       val __FUNCTION__ : string
397
398
399       __FUNCTION__ returns the name of the current function  or  method,  in‐
400       cluding any enclosing modules or classes.
401
402
403       Since 4.12.0
404
405
406
407       val __LOC_OF__ : 'a -> string * 'a
408
409
410       __LOC_OF__ expr returns a pair (loc, expr) where loc is the location of
411       expr in the file currently being parsed by the compiler, with the stan‐
412       dard error format of OCaml: "File %S, line %d, characters %d-%d".
413
414
415       Since 4.02.0
416
417
418
419       val __LINE_OF__ : 'a -> int * 'a
420
421
422       __LINE_OF__  expr  returns a pair (line, expr) , where line is the line
423       number at which the expression expr appears in the file currently being
424       parsed by the compiler.
425
426
427       Since 4.02.0
428
429
430
431       val __POS_OF__ : 'a -> (string * int * int * int) * 'a
432
433
434       __POS_OF__  expr  returns  a  pair  (loc,expr)  ,  where loc is a tuple
435       (file,lnum,cnum,enum) corresponding to the location at  which  the  ex‐
436       pression  expr  appears  in the file currently being parsed by the com‐
437       piler.  file is the current filename, lnum the line  number,  cnum  the
438       character  position in the line and enum the last character position in
439       the line.
440
441
442       Since 4.02.0
443
444
445
446
447   Composition operators
448       val (|>) : 'a -> ('a -> 'b) -> 'b
449
450       Reverse-application operator: x |> f |> g is exactly equivalent to g (f
451       (x))  .  Left-associative operator, see Ocaml_operators for more infor‐
452       mation.
453
454
455       Since 4.01
456
457
458
459       val (@@) : ('a -> 'b) -> 'a -> 'b
460
461       Application operator: g @@ f @@ x is exactly equivalent to g (f (x))  .
462       Right-associative operator, see Ocaml_operators for more information.
463
464
465       Since 4.01
466
467
468
469
470   Integer arithmetic
471       Integers  are  Sys.int_size bits wide.  All operations are taken modulo
472       2^ Sys.int_size .  They do not fail on overflow.
473
474       val (~-) : int -> int
475
476       Unary negation. You can also write - e instead of ~- e .  Unary  opera‐
477       tor, see Ocaml_operators for more information.
478
479
480
481       val (~+) : int -> int
482
483       Unary  addition. You can also write + e instead of ~+ e .  Unary opera‐
484       tor, see Ocaml_operators for more information.
485
486
487       Since 3.12.0
488
489
490
491       val succ : int -> int
492
493
494       succ x is x + 1 .
495
496
497
498       val pred : int -> int
499
500
501       pred x is x - 1 .
502
503
504
505       val (+) : int -> int -> int
506
507       Integer addition.  Left-associative operator, see  Ocaml_operators  for
508       more information.
509
510
511
512       val (-) : int -> int -> int
513
514       Integer  subtraction.  Left-associative operator, , see Ocaml_operators
515       for more information.
516
517
518
519       val ( * ) : int -> int -> int
520
521       Integer multiplication.  Left-associative operator, see Ocaml_operators
522       for more information.
523
524
525
526       val (/) : int -> int -> int
527
528       Integer division.  Integer division rounds the real quotient of its ar‐
529       guments towards zero.  More precisely, if x >= 0 and y > 0 , x /  y  is
530       the  greatest integer less than or equal to the real quotient of x by y
531       .  Moreover, (- x) / y = x / (- y) = - (x / y) .  Left-associative  op‐
532       erator, see Ocaml_operators for more information.
533
534
535       Raises Division_by_zero if the second argument is 0.
536
537
538
539       val (mod) : int -> int -> int
540
541       Integer  remainder.   If y is not zero, the result of x mod y satisfies
542       the following properties: x = (x / y) * y + x mod y and abs(x mod y) <=
543       abs(y) - 1 .  If y = 0 , x mod y raises Division_by_zero .  Note that x
544       mod y is negative only if x  <  0  .   Left-associative  operator,  see
545       Ocaml_operators for more information.
546
547
548       Raises Division_by_zero if y is zero.
549
550
551
552       val abs : int -> int
553
554       Return the absolute value of the argument.  Note that this may be nega‐
555       tive if the argument is min_int .
556
557
558
559       val max_int : int
560
561       The greatest representable integer.
562
563
564
565       val min_int : int
566
567       The smallest representable integer.
568
569
570
571
572   Bitwise operations
573       val (land) : int -> int -> int
574
575       Bitwise logical and.  Left-associative  operator,  see  Ocaml_operators
576       for more information.
577
578
579
580       val (lor) : int -> int -> int
581
582       Bitwise logical or.  Left-associative operator, see Ocaml_operators for
583       more information.
584
585
586
587       val (lxor) : int -> int -> int
588
589       Bitwise logical exclusive or.  Left-associative operator, see Ocaml_op‐
590       erators for more information.
591
592
593
594       val lnot : int -> int
595
596       Bitwise logical negation.
597
598
599
600       val (lsl) : int -> int -> int
601
602
603       n lsl m shifts n to the left by m bits.  The result is unspecified if m
604       < 0 or m > Sys.int_size .  Right-associative operator, see Ocaml_opera‐
605       tors for more information.
606
607
608
609       val (lsr) : int -> int -> int
610
611
612       n  lsr m shifts n to the right by m bits.  This is a logical shift: ze‐
613       roes are inserted regardless of the sign of n .  The result is unspeci‐
614       fied  if  m  < 0 or m > Sys.int_size .  Right-associative operator, see
615       Ocaml_operators for more information.
616
617
618
619       val (asr) : int -> int -> int
620
621
622       n asr m shifts n to the right by m bits.  This is an arithmetic  shift:
623       the sign bit of n is replicated.  The result is unspecified if m < 0 or
624       m > Sys.int_size .  Right-associative operator, see Ocaml_operators for
625       more information.
626
627
628
629
630   Floating-point arithmetic
631       OCaml's floating-point numbers follow the IEEE 754 standard, using dou‐
632       ble precision (64 bits) numbers.  Floating-point operations never raise
633       an  exception  on overflow, underflow, division by zero, etc.  Instead,
634       special IEEE numbers are returned as appropriate, such as infinity  for
635       1.0  /.  0.0  , neg_infinity for -1.0 /. 0.0 , and nan ('not a number')
636       for 0.0 /. 0.0 .  These special numbers then propagate  through  float‐
637       ing-point  computations  as  expected: for instance, 1.0 /. infinity is
638       0.0 , basic arithmetic operations ( +.  , -.  , *.  , /.  ) with nan as
639       an argument return nan , ...
640
641       val (~-.)  : float -> float
642
643       Unary negation. You can also write -. e instead of ~-. e .  Unary oper‐
644       ator, see Ocaml_operators for more information.
645
646
647
648       val (~+.)  : float -> float
649
650       Unary addition. You can also write +. e instead of ~+. e .  Unary oper‐
651       ator, see Ocaml_operators for more information.
652
653
654       Since 3.12.0
655
656
657
658       val (+.)  : float -> float -> float
659
660       Floating-point  addition.   Left-associative operator, see Ocaml_opera‐
661       tors for more information.
662
663
664
665       val (-.)  : float -> float -> float
666
667       Floating-point subtraction.  Left-associative operator, see Ocaml_oper‐
668       ators for more information.
669
670
671
672       val ( *. ) : float -> float -> float
673
674       Floating-point    multiplication.    Left-associative   operator,   see
675       Ocaml_operators for more information.
676
677
678
679       val (/.)  : float -> float -> float
680
681       Floating-point division.  Left-associative operator,  see  Ocaml_opera‐
682       tors for more information.
683
684
685
686       val ( ** ) : float -> float -> float
687
688       Exponentiation.   Right-associative  operator,  see Ocaml_operators for
689       more information.
690
691
692
693       val sqrt : float -> float
694
695       Square root.
696
697
698
699       val exp : float -> float
700
701       Exponential.
702
703
704
705       val log : float -> float
706
707       Natural logarithm.
708
709
710
711       val log10 : float -> float
712
713       Base 10 logarithm.
714
715
716
717       val expm1 : float -> float
718
719
720       expm1 x computes exp x -. 1.0  ,  giving  numerically-accurate  results
721       even if x is close to 0.0 .
722
723
724       Since 3.12.0
725
726
727
728       val log1p : float -> float
729
730
731       log1p  x  computes  log(1.0  +.  x) (natural logarithm), giving numeri‐
732       cally-accurate results even if x is close to 0.0 .
733
734
735       Since 3.12.0
736
737
738
739       val cos : float -> float
740
741       Cosine.  Argument is in radians.
742
743
744
745       val sin : float -> float
746
747       Sine.  Argument is in radians.
748
749
750
751       val tan : float -> float
752
753       Tangent.  Argument is in radians.
754
755
756
757       val acos : float -> float
758
759       Arc cosine.  The argument must fall within the range [-1.0, 1.0] .  Re‐
760       sult is in radians and is between 0.0 and pi .
761
762
763
764       val asin : float -> float
765
766       Arc  sine.   The argument must fall within the range [-1.0, 1.0] .  Re‐
767       sult is in radians and is between -pi/2 and pi/2 .
768
769
770
771       val atan : float -> float
772
773       Arc tangent.  Result is in radians and is between -pi/2 and pi/2 .
774
775
776
777       val atan2 : float -> float -> float
778
779
780       atan2 y x returns the arc tangent of y /. x .  The signs of x and y are
781       used to determine the quadrant of the result.  Result is in radians and
782       is between -pi and pi .
783
784
785
786       val hypot : float -> float -> float
787
788
789       hypot x y returns sqrt(x *. x + y *. y) , that is, the  length  of  the
790       hypotenuse  of  a  right-angled triangle with sides of length x and y ,
791       or, equivalently, the distance of the point (x,y) to origin.  If one of
792       x or y is infinite, returns infinity even if the other is nan .
793
794
795       Since 4.00.0
796
797
798
799       val cosh : float -> float
800
801       Hyperbolic cosine.  Argument is in radians.
802
803
804
805       val sinh : float -> float
806
807       Hyperbolic sine.  Argument is in radians.
808
809
810
811       val tanh : float -> float
812
813       Hyperbolic tangent.  Argument is in radians.
814
815
816
817       val acosh : float -> float
818
819       Hyperbolic  arc  cosine.  The argument must fall within the range [1.0,
820       inf] .  Result is in radians and is between 0.0 and inf .
821
822
823       Since 4.13.0
824
825
826
827       val asinh : float -> float
828
829       Hyperbolic arc sine.  The argument and result  range  over  the  entire
830       real line.  Result is in radians.
831
832
833       Since 4.13.0
834
835
836
837       val atanh : float -> float
838
839       Hyperbolic arc tangent.  The argument must fall within the range [-1.0,
840       1.0] .  Result is in radians and ranges over the entire real line.
841
842
843       Since 4.13.0
844
845
846
847       val ceil : float -> float
848
849       Round above to an integer value.  ceil  f  returns  the  least  integer
850       value greater than or equal to f .  The result is returned as a float.
851
852
853
854       val floor : float -> float
855
856       Round  below to an integer value.  floor f returns the greatest integer
857       value less than or equal to f .  The result is returned as a float.
858
859
860
861       val abs_float : float -> float
862
863
864       abs_float f returns the absolute value of f .
865
866
867
868       val copysign : float -> float -> float
869
870
871       copysign x y returns a float whose absolute value  is  that  of  x  and
872       whose  sign  is that of y .  If x is nan , returns nan .  If y is nan ,
873       returns either x or -. x , but it is not specified which.
874
875
876       Since 4.00.0
877
878
879
880       val mod_float : float -> float -> float
881
882
883       mod_float a b returns the remainder of a with respect to b .   The  re‐
884       turned  value  is  a -. n *. b , where n is the quotient a /. b rounded
885       towards zero to an integer.
886
887
888
889       val frexp : float -> float * int
890
891
892       frexp f returns the pair of the significant and the  exponent  of  f  .
893       When  f is zero, the significant x and the exponent n of f are equal to
894       zero.  When f is non-zero, they are defined by f = x *. 2 ** n and  0.5
895       <= x < 1.0 .
896
897
898
899       val ldexp : float -> int -> float
900
901
902       ldexp x n returns x *. 2 ** n .
903
904
905
906       val modf : float -> float * float
907
908
909       modf f returns the pair of the fractional and integral part of f .
910
911
912
913       val float : int -> float
914
915       Same as float_of_int .
916
917
918
919       val float_of_int : int -> float
920
921       Convert an integer to floating-point.
922
923
924
925       val truncate : float -> int
926
927       Same as int_of_float .
928
929
930
931       val int_of_float : float -> int
932
933       Truncate  the given floating-point number to an integer.  The result is
934       unspecified if the argument is nan or falls outside the range of repre‐
935       sentable integers.
936
937
938
939       val infinity : float
940
941       Positive infinity.
942
943
944
945       val neg_infinity : float
946
947       Negative infinity.
948
949
950
951       val nan : float
952
953       A  special floating-point value denoting the result of an undefined op‐
954       eration such as 0.0 /. 0.0 .  Stands for 'not a  number'.   Any  float‐
955       ing-point operation with nan as argument returns nan as result.  As for
956       floating-point comparisons, = , < , <= , > and >= return false  and  <>
957       returns true if one or both of their arguments is nan .
958
959
960
961       val max_float : float
962
963       The largest positive finite value of type float .
964
965
966
967       val min_float : float
968
969       The smallest positive, non-zero, non-denormalized value of type float .
970
971
972
973       val epsilon_float : float
974
975       The  difference  between  1.0  and  the  smallest exactly representable
976       floating-point number greater than 1.0 .
977
978
979       type fpclass =
980        | FP_normal  (* Normal number, none of the below
981        *)
982        | FP_subnormal  (* Number very close to 0.0, has reduced precision
983        *)
984        | FP_zero  (* Number is 0.0 or -0.0
985        *)
986        | FP_infinite  (* Number is positive or negative infinity
987        *)
988        | FP_nan  (* Not a number: result of an undefined operation
989        *)
990
991
992       The five classes of floating-point numbers, as determined by the  clas‐
993       sify_float function.
994
995
996
997       val classify_float : float -> fpclass
998
999       Return the class of the given floating-point number: normal, subnormal,
1000       zero, infinite, or not a number.
1001
1002
1003
1004
1005   String operations
1006       More string operations are provided in module String .
1007
1008       val (^) : string -> string -> string
1009
1010       String concatenation.  Right-associative operator, see  Ocaml_operators
1011       for more information.
1012
1013
1014       Raises   Invalid_argument   if   the   result   is   longer  then  than
1015       Sys.max_string_length bytes.
1016
1017
1018
1019
1020   Character operations
1021       More character operations are provided in module Char .
1022
1023       val int_of_char : char -> int
1024
1025       Return the ASCII code of the argument.
1026
1027
1028
1029       val char_of_int : int -> char
1030
1031       Return the character with the given ASCII code.
1032
1033
1034       Raises Invalid_argument if the argument is outside the range 0--255.
1035
1036
1037
1038
1039   Unit operations
1040       val ignore : 'a -> unit
1041
1042       Discard the value of its argument and return () .   For  instance,  ig‐
1043       nore(f x) discards the result of the side-effecting function f .  It is
1044       equivalent to f x; () , except that the latter may generate a  compiler
1045       warning; writing ignore(f x) instead avoids the warning.
1046
1047
1048
1049
1050   String conversion functions
1051       val string_of_bool : bool -> string
1052
1053       Return  the  string representation of a boolean. As the returned values
1054       may be shared, the user should not modify them directly.
1055
1056
1057
1058       val bool_of_string_opt : string -> bool option
1059
1060       Convert the given string to a boolean.
1061
1062       Return None if the string is not "true" or "false" .
1063
1064
1065       Since 4.05
1066
1067
1068
1069       val bool_of_string : string -> bool
1070
1071       Same   as   bool_of_string_opt    ,    but    raise    Invalid_argument
1072       "bool_of_string" instead of returning None .
1073
1074
1075
1076       val string_of_int : int -> string
1077
1078       Return the string representation of an integer, in decimal.
1079
1080
1081
1082       val int_of_string_opt : string -> int option
1083
1084       Convert  the given string to an integer.  The string is read in decimal
1085       (by default, or if the string begins with 0u ), in hexadecimal  (if  it
1086       begins  with  0x or 0X ), in octal (if it begins with 0o or 0O ), or in
1087       binary (if it begins with 0b or 0B ).
1088
1089       The 0u prefix reads the input as an unsigned integer in the  range  [0,
1090       2*max_int+1]  .   If  the  input exceeds max_int it is converted to the
1091       signed integer min_int + input - max_int - 1 .
1092
1093       The _ (underscore) character can appear anywhere in the string  and  is
1094       ignored.
1095
1096       Return None if the given string is not a valid representation of an in‐
1097       teger, or if the integer represented exceeds the range of integers rep‐
1098       resentable in type int .
1099
1100
1101       Since 4.05
1102
1103
1104
1105       val int_of_string : string -> int
1106
1107       Same  as  int_of_string_opt , but raise Failure "int_of_string" instead
1108       of returning None .
1109
1110
1111
1112       val string_of_float : float -> string
1113
1114       Return the string representation of a floating-point number.
1115
1116
1117
1118       val float_of_string_opt : string -> float option
1119
1120       Convert the given string to a float.  The string is read in decimal (by
1121       default) or in hexadecimal (marked by 0x or 0X ).
1122
1123       The  format of decimal floating-point numbers is [-] dd.ddd (e|E) [+|-]
1124       dd , where d stands for a decimal digit.
1125
1126       The format of hexadecimal floating-point numbers is [-]  0(x|X)  hh.hhh
1127       (p|P)  [+|-]  dd  , where h stands for an hexadecimal digit and d for a
1128       decimal digit.
1129
1130       In both cases, at least one of the integer and fractional parts must be
1131       given; the exponent part is optional.
1132
1133       The  _  (underscore) character can appear anywhere in the string and is
1134       ignored.
1135
1136       Depending on the execution platforms, other representations  of  float‐
1137       ing-point numbers can be accepted, but should not be relied upon.
1138
1139       Return  None  if  the  given  string is not a valid representation of a
1140       float.
1141
1142
1143       Since 4.05
1144
1145
1146
1147       val float_of_string : string -> float
1148
1149       Same as float_of_string_opt , but raise Failure  "float_of_string"  in‐
1150       stead of returning None .
1151
1152
1153
1154
1155   Pair operations
1156       val fst : 'a * 'b -> 'a
1157
1158       Return the first component of a pair.
1159
1160
1161
1162       val snd : 'a * 'b -> 'b
1163
1164       Return the second component of a pair.
1165
1166
1167
1168
1169   List operations
1170       More list operations are provided in module List .
1171
1172       val (@) : 'a list -> 'a list -> 'a list
1173
1174       List concatenation.  Not tail-recursive (length of the first argument).
1175       Right-associative operator, see Ocaml_operators for more information.
1176
1177
1178
1179
1180   Input/output
1181       Note: all input/output functions can raise Sys_error  when  the  system
1182       calls they invoke fail.
1183
1184       type in_channel
1185
1186
1187       The type of input channel.
1188
1189
1190       type out_channel
1191
1192
1193       The type of output channel.
1194
1195
1196
1197       val stdin : in_channel
1198
1199       The standard input for the process.
1200
1201
1202
1203       val stdout : out_channel
1204
1205       The standard output for the process.
1206
1207
1208
1209       val stderr : out_channel
1210
1211       The standard error output for the process.
1212
1213
1214
1215
1216   Output functions on standard output
1217       val print_char : char -> unit
1218
1219       Print a character on standard output.
1220
1221
1222
1223       val print_string : string -> unit
1224
1225       Print a string on standard output.
1226
1227
1228
1229       val print_bytes : bytes -> unit
1230
1231       Print a byte sequence on standard output.
1232
1233
1234       Since 4.02.0
1235
1236
1237
1238       val print_int : int -> unit
1239
1240       Print an integer, in decimal, on standard output.
1241
1242
1243
1244       val print_float : float -> unit
1245
1246       Print a floating-point number, in decimal, on standard output.
1247
1248
1249
1250       val print_endline : string -> unit
1251
1252       Print a string, followed by a newline character, on standard output and
1253       flush standard output.
1254
1255
1256
1257       val print_newline : unit -> unit
1258
1259       Print a newline character on standard output, and flush  standard  out‐
1260       put. This can be used to simulate line buffering of standard output.
1261
1262
1263
1264
1265   Output functions on standard error
1266       val prerr_char : char -> unit
1267
1268       Print a character on standard error.
1269
1270
1271
1272       val prerr_string : string -> unit
1273
1274       Print a string on standard error.
1275
1276
1277
1278       val prerr_bytes : bytes -> unit
1279
1280       Print a byte sequence on standard error.
1281
1282
1283       Since 4.02.0
1284
1285
1286
1287       val prerr_int : int -> unit
1288
1289       Print an integer, in decimal, on standard error.
1290
1291
1292
1293       val prerr_float : float -> unit
1294
1295       Print a floating-point number, in decimal, on standard error.
1296
1297
1298
1299       val prerr_endline : string -> unit
1300
1301       Print  a  string, followed by a newline character on standard error and
1302       flush standard error.
1303
1304
1305
1306       val prerr_newline : unit -> unit
1307
1308       Print a newline character on standard error, and flush standard error.
1309
1310
1311
1312
1313   Input functions on standard input
1314       val read_line : unit -> string
1315
1316       Flush standard output, then read characters from standard input until a
1317       newline  character  is encountered. Return the string of all characters
1318       read, without the newline character at the end.
1319
1320
1321
1322       val read_int_opt : unit -> int option
1323
1324       Flush standard output, then read one line from standard input and  con‐
1325       vert it to an integer.
1326
1327       Return  None if the line read is not a valid representation of an inte‐
1328       ger.
1329
1330
1331       Since 4.05
1332
1333
1334
1335       val read_int : unit -> int
1336
1337       Same as read_int_opt , but raise Failure "int_of_string" instead of re‐
1338       turning None .
1339
1340
1341
1342       val read_float_opt : unit -> float option
1343
1344       Flush  standard output, then read one line from standard input and con‐
1345       vert it to a floating-point number.
1346
1347       Return None if the line read is not a valid representation of a  float‐
1348       ing-point number.
1349
1350
1351       Since 4.05.0
1352
1353
1354
1355       val read_float : unit -> float
1356
1357       Same as read_float_opt , but raise Failure "float_of_string" instead of
1358       returning None .
1359
1360
1361
1362
1363   General output functions
1364       type open_flag =
1365        | Open_rdonly  (* open for reading.
1366        *)
1367        | Open_wronly  (* open for writing.
1368        *)
1369        | Open_append  (* open for appending: always write at end of file.
1370        *)
1371        | Open_creat  (* create the file if it does not exist.
1372        *)
1373        | Open_trunc  (* empty the file if it already exists.
1374        *)
1375        | Open_excl  (* fail if Open_creat and the file already exists.
1376        *)
1377        | Open_binary  (* open in binary mode (no conversion).
1378        *)
1379        | Open_text  (* open in text mode (may perform conversions).
1380        *)
1381        | Open_nonblock  (* open in non-blocking mode.
1382        *)
1383
1384
1385       Opening modes for open_out_gen and open_in_gen .
1386
1387
1388
1389       val open_out : string -> out_channel
1390
1391       Open the named file for writing, and return a  new  output  channel  on
1392       that  file,  positioned at the beginning of the file. The file is trun‐
1393       cated to zero length if it already exists. It is created if it does not
1394       already exists.
1395
1396
1397
1398       val open_out_bin : string -> out_channel
1399
1400       Same  as  open_out  , but the file is opened in binary mode, so that no
1401       translation takes place during writes. On operating systems that do not
1402       distinguish  between  text  mode and binary mode, this function behaves
1403       like open_out .
1404
1405
1406
1407       val open_out_gen : open_flag list -> int -> string -> out_channel
1408
1409
1410       open_out_gen mode perm filename opens the named file  for  writing,  as
1411       described  above.  The  extra argument mode specifies the opening mode.
1412       The extra argument perm specifies the file  permissions,  in  case  the
1413       file  must  be created.  open_out and open_out_bin are special cases of
1414       this function.
1415
1416
1417
1418       val flush : out_channel -> unit
1419
1420       Flush the buffer associated with the given output  channel,  performing
1421       all pending writes on that channel.  Interactive programs must be care‐
1422       ful about flushing standard output and  standard  error  at  the  right
1423       time.
1424
1425
1426
1427       val flush_all : unit -> unit
1428
1429       Flush all open output channels; ignore errors.
1430
1431
1432
1433       val output_char : out_channel -> char -> unit
1434
1435       Write the character on the given output channel.
1436
1437
1438
1439       val output_string : out_channel -> string -> unit
1440
1441       Write the string on the given output channel.
1442
1443
1444
1445       val output_bytes : out_channel -> bytes -> unit
1446
1447       Write the byte sequence on the given output channel.
1448
1449
1450       Since 4.02.0
1451
1452
1453
1454       val output : out_channel -> bytes -> int -> int -> unit
1455
1456
1457       output  oc  buf  pos len writes len characters from byte sequence buf ,
1458       starting at offset pos , to the given output channel oc .
1459
1460
1461       Raises Invalid_argument if pos and len do not designate a  valid  range
1462       of buf .
1463
1464
1465
1466       val output_substring : out_channel -> string -> int -> int -> unit
1467
1468       Same  as  output  but  take  a string as argument instead of a byte se‐
1469       quence.
1470
1471
1472       Since 4.02.0
1473
1474
1475
1476       val output_byte : out_channel -> int -> unit
1477
1478       Write one 8-bit integer (as the single character with that code) on the
1479       given output channel. The given integer is taken modulo 256.
1480
1481
1482
1483       val output_binary_int : out_channel -> int -> unit
1484
1485       Write  one  integer in binary format (4 bytes, big-endian) on the given
1486       output channel.  The given integer is taken modulo 2^32.  The only  re‐
1487       liable  way  to  read it back is through the input_binary_int function.
1488       The format is compatible across all machines for  a  given  version  of
1489       OCaml.
1490
1491
1492
1493       val output_value : out_channel -> 'a -> unit
1494
1495       Write  the  representation of a structured value of any type to a chan‐
1496       nel. Circularities and sharing inside the value are detected  and  pre‐
1497       served.  The object can be read back, by the function input_value . See
1498       the description of module Marshal for more  information.   output_value
1499       is equivalent to Marshal.to_channel with an empty list of flags.
1500
1501
1502
1503       val seek_out : out_channel -> int -> unit
1504
1505
1506       seek_out  chan pos sets the current writing position to pos for channel
1507       chan . This works only for regular files. On files of other kinds (such
1508       as terminals, pipes and sockets), the behavior is unspecified.
1509
1510
1511
1512       val pos_out : out_channel -> int
1513
1514       Return  the  current  writing position for the given channel.  Does not
1515       work on channels opened with the Open_append flag (returns  unspecified
1516       results).   For  files  opened in text mode under Windows, the returned
1517       position is approximate (owing to end-of-line conversion); in  particu‐
1518       lar, saving the current position with pos_out , then going back to this
1519       position using seek_out will not work.  For this programming  idiom  to
1520       work reliably and portably, the file must be opened in binary mode.
1521
1522
1523
1524       val out_channel_length : out_channel -> int
1525
1526       Return the size (number of characters) of the regular file on which the
1527       given channel is opened.  If the channel is opened on a  file  that  is
1528       not a regular file, the result is meaningless.
1529
1530
1531
1532       val close_out : out_channel -> unit
1533
1534       Close  the given channel, flushing all buffered write operations.  Out‐
1535       put functions raise a Sys_error exception when they are  applied  to  a
1536       closed  output  channel,  except close_out and flush , which do nothing
1537       when applied to an already closed channel.   Note  that  close_out  may
1538       raise  Sys_error if the operating system signals an error when flushing
1539       or closing.
1540
1541
1542
1543       val close_out_noerr : out_channel -> unit
1544
1545       Same as close_out , but ignore all errors.
1546
1547
1548
1549       val set_binary_mode_out : out_channel -> bool -> unit
1550
1551
1552       set_binary_mode_out oc true sets the channel  oc  to  binary  mode:  no
1553       translations  take  place  during output.  set_binary_mode_out oc false
1554       sets the channel oc to text mode: depending on  the  operating  system,
1555       some  translations  may  take place during output.  For instance, under
1556       Windows, end-of-lines will be translated from \n to \r\n .  This  func‐
1557       tion  has no effect under operating systems that do not distinguish be‐
1558       tween text mode and binary mode.
1559
1560
1561
1562
1563   General input functions
1564       val open_in : string -> in_channel
1565
1566       Open the named file for reading, and return a new input channel on that
1567       file, positioned at the beginning of the file.
1568
1569
1570
1571       val open_in_bin : string -> in_channel
1572
1573       Same  as  open_in  ,  but the file is opened in binary mode, so that no
1574       translation takes place during reads. On operating systems that do  not
1575       distinguish  between  text  mode and binary mode, this function behaves
1576       like open_in .
1577
1578
1579
1580       val open_in_gen : open_flag list -> int -> string -> in_channel
1581
1582
1583       open_in_gen mode perm filename opens the named file for reading, as de‐
1584       scribed  above.  The  extra arguments mode and perm specify the opening
1585       mode and file permissions.  open_in and open_in_bin are  special  cases
1586       of this function.
1587
1588
1589
1590       val input_char : in_channel -> char
1591
1592       Read one character from the given input channel.
1593
1594
1595       Raises End_of_file if there are no more characters to read.
1596
1597
1598
1599       val input_line : in_channel -> string
1600
1601       Read characters from the given input channel, until a newline character
1602       is encountered. Return the string of all characters read,  without  the
1603       newline character at the end.
1604
1605
1606       Raises  End_of_file  if the end of the file is reached at the beginning
1607       of line.
1608
1609
1610
1611       val input : in_channel -> bytes -> int -> int -> int
1612
1613
1614       input ic buf pos len reads up to len characters from the given  channel
1615       ic  ,  storing them in byte sequence buf , starting at character number
1616       pos .  It returns the actual number of characters read, between  0  and
1617       len  (inclusive).   A  return value of 0 means that the end of file was
1618       reached.  A return value between 0 and len exclusive means that not all
1619       requested  len  characters were read, either because no more characters
1620       were available at that time, or because  the  implementation  found  it
1621       convenient to do a partial read; input must be called again to read the
1622       remaining characters, if desired.  (See also really_input  for  reading
1623       exactly  len characters.)  Exception Invalid_argument "input" is raised
1624       if pos and len do not designate a valid range of buf .
1625
1626
1627
1628       val really_input : in_channel -> bytes -> int -> int -> unit
1629
1630
1631       really_input ic buf pos len reads len  characters  from  channel  ic  ,
1632       storing them in byte sequence buf , starting at character number pos .
1633
1634
1635       Raises  End_of_file if the end of file is reached before len characters
1636       have been read.
1637
1638
1639       Raises Invalid_argument if pos and len do not designate a  valid  range
1640       of buf .
1641
1642
1643
1644       val really_input_string : in_channel -> int -> string
1645
1646
1647       really_input_string ic len reads len characters from channel ic and re‐
1648       turns them in a new string.
1649
1650
1651       Since 4.02.0
1652
1653
1654       Raises End_of_file if the end of file is reached before len  characters
1655       have been read.
1656
1657
1658
1659       val input_byte : in_channel -> int
1660
1661       Same  as  input_char  ,  but  return the 8-bit integer representing the
1662       character.
1663
1664
1665       Raises End_of_file if an end of file was reached.
1666
1667
1668
1669       val input_binary_int : in_channel -> int
1670
1671       Read an integer encoded in binary format (4 bytes, big-endian) from the
1672       given input channel. See output_binary_int .
1673
1674
1675       Raises  End_of_file if an end of file was reached while reading the in‐
1676       teger.
1677
1678
1679
1680       val input_value : in_channel -> 'a
1681
1682       Read the representation of a structured  value,  as  produced  by  out‐
1683       put_value , and return the corresponding value.  This function is iden‐
1684       tical to Marshal.from_channel ; see the description of  module  Marshal
1685       for more information, in particular concerning the lack of type safety.
1686
1687
1688
1689       val seek_in : in_channel -> int -> unit
1690
1691
1692       seek_in  chan  pos sets the current reading position to pos for channel
1693       chan . This works only for regular files. On files of other kinds,  the
1694       behavior is unspecified.
1695
1696
1697
1698       val pos_in : in_channel -> int
1699
1700       Return  the  current reading position for the given channel.  For files
1701       opened in text mode under Windows, the returned position is approximate
1702       (owing  to  end-of-line  conversion); in particular, saving the current
1703       position with pos_in , then going back to this position  using  seek_in
1704       will  not  work.   For  this  programming  idiom  to  work reliably and
1705       portably, the file must be opened in binary mode.
1706
1707
1708
1709       val in_channel_length : in_channel -> int
1710
1711       Return the size (number of characters) of the regular file on which the
1712       given  channel  is  opened.  If the channel is opened on a file that is
1713       not a regular file, the result is meaningless.  The returned size  does
1714       not  take  into  account  the end-of-line translations that can be per‐
1715       formed when reading from a channel opened in text mode.
1716
1717
1718
1719       val close_in : in_channel -> unit
1720
1721       Close the given channel.  Input functions raise a  Sys_error  exception
1722       when  they  are  applied  to  a closed input channel, except close_in ,
1723       which does nothing when applied to an already closed channel.
1724
1725
1726
1727       val close_in_noerr : in_channel -> unit
1728
1729       Same as close_in , but ignore all errors.
1730
1731
1732
1733       val set_binary_mode_in : in_channel -> bool -> unit
1734
1735
1736       set_binary_mode_in ic true sets the  channel  ic  to  binary  mode:  no
1737       translations  take  place  during  input.  set_binary_mode_out ic false
1738       sets the channel ic to text mode: depending on  the  operating  system,
1739       some  translations  may  take  place during input.  For instance, under
1740       Windows, end-of-lines will be translated from \r\n to \n .  This  func‐
1741       tion  has no effect under operating systems that do not distinguish be‐
1742       tween text mode and binary mode.
1743
1744
1745
1746
1747   Operations on large files
1748       module LargeFile : sig end
1749
1750
1751       Operations on large files.  This sub-module provides 64-bit variants of
1752       the  channel  functions  that manipulate file positions and file sizes.
1753       By representing positions and sizes by 64-bit integers  (type  int64  )
1754       instead  of regular integers (type int ), these alternate functions al‐
1755       low operating on files whose sizes are greater than max_int .
1756
1757
1758
1759
1760   References
1761       type 'a ref = {
1762
1763       mutable contents : 'a ;
1764        }
1765
1766
1767       The type of references (mutable indirection cells) containing  a  value
1768       of type 'a .
1769
1770
1771
1772       val ref : 'a -> 'a ref
1773
1774       Return a fresh reference containing the given value.
1775
1776
1777
1778       val (!)  : 'a ref -> 'a
1779
1780
1781       !r  returns  the current contents of reference r .  Equivalent to fun r
1782       -> r.contents .  Unary operator, see Ocaml_operators for more  informa‐
1783       tion.
1784
1785
1786
1787       val (:=) : 'a ref -> 'a -> unit
1788
1789
1790       r := a stores the value of a in reference r .  Equivalent to fun r v ->
1791       r.contents <- v .  Right-associative operator, see Ocaml_operators  for
1792       more information.
1793
1794
1795
1796       val incr : int ref -> unit
1797
1798       Increment  the integer contained in the given reference.  Equivalent to
1799       fun r -> r := succ !r .
1800
1801
1802
1803       val decr : int ref -> unit
1804
1805       Decrement the integer contained in the given reference.  Equivalent  to
1806       fun r -> r := pred !r .
1807
1808
1809
1810
1811   Result type
1812       type ('a, 'b) result =
1813        | Ok of 'a
1814        | Error of 'b
1815
1816
1817       Since 4.03.0
1818
1819
1820
1821
1822   Operations on format strings
1823       Format  strings  are character strings with special lexical conventions
1824       that defines the functionality  of  formatted  input/output  functions.
1825       Format  strings  are  used  to read data with formatted input functions
1826       from module Scanf and to print data  with  formatted  output  functions
1827       from modules Printf and Format .
1828
1829       Format strings are made of three kinds of entities:
1830
1831       -conversions  specifications,  introduced  by the special character '%'
1832       followed by one or more characters specifying what kind of argument  to
1833       read or print,
1834
1835       -formatting  indications,  introduced by the special character '@' fol‐
1836       lowed by one or more characters specifying how to read or print the ar‐
1837       gument,
1838
1839       -plain  characters  that are regular characters with usual lexical con‐
1840       ventions. Plain characters specify string literals to be  read  in  the
1841       input or printed in the output.
1842
1843       There  is  an  additional lexical rule to escape the special characters
1844       '%' and '@' in format strings: if a special  character  follows  a  '%'
1845       character,  it is treated as a plain character. In other words, "%%" is
1846       considered as a plain '%' and "%@" as a plain '@' .
1847
1848       For more information about conversion specifications and formatting in‐
1849       dications  available,  read the documentation of modules Scanf , Printf
1850       and Format .
1851
1852       Format strings have a general and highly polymorphic type ('a, 'b,  'c,
1853       'd, 'e, 'f) format6 .  The two simplified types, format and format4 be‐
1854       low are included for backward compatibility with  earlier  releases  of
1855       OCaml.
1856
1857       The meaning of format string type parameters is as follows:
1858
1859
1860       -  'a  is the type of the parameters of the format for formatted output
1861       functions ( printf -style functions); 'a is the type of the values read
1862       by the format for formatted input functions ( scanf -style functions).
1863
1864
1865       -  'b is the type of input source for formatted input functions and the
1866       type of output target  for  formatted  output  functions.   For  printf
1867       -style functions from module Printf , 'b is typically out_channel ; for
1868       printf -style functions from module  Format  ,  'b  is  typically  For‐
1869       mat.formatter  ;  for  scanf -style functions from module Scanf , 'b is
1870       typically Scanf.Scanning.in_channel .
1871
1872       Type argument 'b is also the type of the first argument given to user's
1873       defined  printing  functions  for %a and %t conversions, and user's de‐
1874       fined reading functions for %r conversion.
1875
1876
1877       - 'c is the type of the result of the %a and %t printing functions, and
1878       also  the  type  of  the  argument transmitted to the first argument of
1879       kprintf -style functions or to the kscanf -style functions.
1880
1881
1882       - 'd is the type of parameters for the scanf -style functions.
1883
1884
1885       - 'e is the type of the receiver function for the  scanf  -style  func‐
1886       tions.
1887
1888
1889       -  'f is the final result type of a formatted input/output function in‐
1890       vocation: for the printf -style functions, it is typically unit  ;  for
1891       the  scanf -style functions, it is typically the result type of the re‐
1892       ceiver function.
1893
1894
1895       type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e,  'f)  Cam‐
1896       linternalFormatBasics.format6
1897
1898
1899
1900
1901       type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
1902
1903
1904
1905
1906       type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
1907
1908
1909
1910
1911
1912       val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
1913
1914       Converts a format string into a string.
1915
1916
1917
1918       val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c,
1919       'd, 'e, 'f) format6
1920
1921
1922       format_of_string s returns a format string read from the string literal
1923       s  .   Note: format_of_string can not convert a string argument that is
1924       not a literal. If you need this functionality,  use  the  more  general
1925       Scanf.format_from_string function.
1926
1927
1928
1929       val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h)
1930       format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
1931
1932
1933       f1 ^^ f2 catenates format strings f1 and f2 . The result  is  a  format
1934       string  that behaves as the concatenation of format strings f1 and f2 :
1935       in case of formatted output, it accepts arguments from f1 , then  argu‐
1936       ments  from f2 ; in case of formatted input, it returns results from f1
1937       , then results from f2 .  Right-associative operator, see  Ocaml_opera‐
1938       tors for more information.
1939
1940
1941
1942
1943   Program termination
1944       val exit : int -> 'a
1945
1946       Terminate the process, returning the given status code to the operating
1947       system: usually 0 to indicate no errors, and a small  positive  integer
1948       to  indicate  failure.   All  open  output  channels  are  flushed with
1949       flush_all .  An implicit exit 0 is performed each time a program termi‐
1950       nates  normally.  An implicit exit 2 is performed if the program termi‐
1951       nates early because of an uncaught exception.
1952
1953
1954
1955       val at_exit : (unit -> unit) -> unit
1956
1957       Register the given function to be called at program  termination  time.
1958       The  functions  registered with at_exit will be called when the program
1959       does any of the following:
1960
1961       -executes exit
1962
1963
1964       -terminates, either normally or because of an uncaught exception
1965
1966       -executes the C function caml_shutdown .  The functions are  called  in
1967       'last  in,  first  out'  order:  the  function most recently added with
1968       at_exit is called first.
1969
1970
1971
1972
1973
1974   Standard library modules
1975       module Arg : (module Stdlib__Arg)
1976
1977
1978
1979
1980       module Array : (module Stdlib__Array)
1981
1982
1983
1984
1985       module ArrayLabels : (module Stdlib__ArrayLabels)
1986
1987
1988
1989
1990       module Atomic : (module Stdlib__Atomic)
1991
1992
1993
1994
1995       module Bigarray : (module Stdlib__Bigarray)
1996
1997
1998
1999
2000       module Bool : (module Stdlib__Bool)
2001
2002
2003
2004
2005       module Buffer : (module Stdlib__Buffer)
2006
2007
2008
2009
2010       module Bytes : (module Stdlib__Bytes)
2011
2012
2013
2014
2015       module BytesLabels : (module Stdlib__BytesLabels)
2016
2017
2018
2019
2020       module Callback : (module Stdlib__Callback)
2021
2022
2023
2024
2025       module Char : (module Stdlib__Char)
2026
2027
2028
2029
2030       module Complex : (module Stdlib__Complex)
2031
2032
2033
2034
2035       module Digest : (module Stdlib__Digest)
2036
2037
2038
2039
2040       module Either : (module Stdlib__Either)
2041
2042
2043
2044
2045       module Ephemeron : (module Stdlib__Ephemeron)
2046
2047
2048
2049
2050       module Filename : (module Stdlib__Filename)
2051
2052
2053
2054
2055       module Float : (module Stdlib__Float)
2056
2057
2058
2059
2060       module Format : (module Stdlib__Format)
2061
2062
2063
2064
2065       module Fun : (module Stdlib__Fun)
2066
2067
2068
2069
2070       module Gc : (module Stdlib__Gc)
2071
2072
2073
2074
2075       module Genlex : (module Stdlib__Genlex)
2076
2077
2078
2079
2080       module Hashtbl : (module Stdlib__Hashtbl)
2081
2082
2083
2084
2085       module Int : (module Stdlib__Int)
2086
2087
2088
2089
2090       module Int32 : (module Stdlib__Int32)
2091
2092
2093
2094
2095       module Int64 : (module Stdlib__Int64)
2096
2097
2098
2099
2100       module Lazy : (module Stdlib__Lazy)
2101
2102
2103
2104
2105       module Lexing : (module Stdlib__Lexing)
2106
2107
2108
2109
2110       module List : (module Stdlib__List)
2111
2112
2113
2114
2115       module ListLabels : (module Stdlib__ListLabels)
2116
2117
2118
2119
2120       module Map : (module Stdlib__Map)
2121
2122
2123
2124
2125       module Marshal : (module Stdlib__Marshal)
2126
2127
2128
2129
2130       module MoreLabels : (module Stdlib__MoreLabels)
2131
2132
2133
2134
2135       module Nativeint : (module Stdlib__Nativeint)
2136
2137
2138
2139
2140       module Obj : (module Stdlib__Obj)
2141
2142
2143
2144
2145       module Oo : (module Stdlib__Oo)
2146
2147
2148
2149
2150       module Option : (module Stdlib__Option)
2151
2152
2153
2154
2155       module Parsing : (module Stdlib__Parsing)
2156
2157
2158
2159
2160       module Pervasives : (module Stdlib__Pervasives)
2161
2162
2163
2164
2165       module Printexc : (module Stdlib__Printexc)
2166
2167
2168
2169
2170       module Printf : (module Stdlib__Printf)
2171
2172
2173
2174
2175       module Queue : (module Stdlib__Queue)
2176
2177
2178
2179
2180       module Random : (module Stdlib__Random)
2181
2182
2183
2184
2185       module Result : (module Stdlib__Result)
2186
2187
2188
2189
2190       module Scanf : (module Stdlib__Scanf)
2191
2192
2193
2194
2195       module Seq : (module Stdlib__Seq)
2196
2197
2198
2199
2200       module Set : (module Stdlib__Set)
2201
2202
2203
2204
2205       module Stack : (module Stdlib__Stack)
2206
2207
2208
2209
2210       module StdLabels : (module Stdlib__StdLabels)
2211
2212
2213
2214
2215       module Stream : (module Stdlib__Stream)
2216
2217
2218
2219
2220       module String : (module Stdlib__String)
2221
2222
2223
2224
2225       module StringLabels : (module Stdlib__StringLabels)
2226
2227
2228
2229
2230       module Sys : (module Stdlib__Sys)
2231
2232
2233
2234
2235       module Uchar : (module Stdlib__Uchar)
2236
2237
2238
2239
2240       module Unit : (module Stdlib__Unit)
2241
2242
2243
2244
2245       module Weak : (module Stdlib__Weak)
2246
2247
2248
2249
2250
2251
2252
2253OCamldoc                          2022-02-04                         Stdlib(3)
Impressum