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

NAME

6       Stdlib.Pervasives - no description
7

Module

9       Module   Stdlib.Pervasives
10

Documentation

12       Module Pervasives
13        : (module Stdlib__pervasives)
14
15
16
17
18
19
20
21
22       val raise : exn -> 'a
23
24
25
26
27       val raise_notrace : exn -> 'a
28
29
30
31
32       val invalid_arg : string -> 'a
33
34
35
36
37       val failwith : string -> 'a
38
39
40
41
42       exception Exit
43
44
45
46
47
48       val (=) : 'a -> 'a -> bool
49
50
51
52
53       val (<>) : 'a -> 'a -> bool
54
55
56
57
58       val (<) : 'a -> 'a -> bool
59
60
61
62
63       val (>) : 'a -> 'a -> bool
64
65
66
67
68       val (<=) : 'a -> 'a -> bool
69
70
71
72
73       val (>=) : 'a -> 'a -> bool
74
75
76
77
78       val compare : 'a -> 'a -> int
79
80
81
82
83       val min : 'a -> 'a -> 'a
84
85
86
87
88       val max : 'a -> 'a -> 'a
89
90
91
92
93       val (==) : 'a -> 'a -> bool
94
95
96
97
98       val (!=) : 'a -> 'a -> bool
99
100
101
102
103       val not : bool -> bool
104
105
106
107
108       val (&&) : bool -> bool -> bool
109
110
111
112
113       val (&) : bool -> bool -> bool
114
115
116
117
118       val (||) : bool -> bool -> bool
119
120
121
122
123       val (or) : bool -> bool -> bool
124
125
126
127
128       val __LOC__ : string
129
130
131
132
133       val __FILE__ : string
134
135
136
137
138       val __LINE__ : int
139
140
141
142
143       val __MODULE__ : string
144
145
146
147
148       val __POS__ : string * int * int * int
149
150
151
152
153       val __LOC_OF__ : 'a -> string * 'a
154
155
156
157
158       val __LINE_OF__ : 'a -> int * 'a
159
160
161
162
163       val __POS_OF__ : 'a -> (string * int * int * int) * 'a
164
165
166
167
168       val (|>) : 'a -> ('a -> 'b) -> 'b
169
170
171
172
173       val (@@) : ('a -> 'b) -> 'a -> 'b
174
175
176
177
178       val (~-) : int -> int
179
180
181
182
183       val (~+) : int -> int
184
185
186
187
188       val succ : int -> int
189
190
191
192
193       val pred : int -> int
194
195
196
197
198       val (+) : int -> int -> int
199
200
201
202
203       val (-) : int -> int -> int
204
205
206
207
208       val ( * ) : int -> int -> int
209
210
211
212
213       val (/) : int -> int -> int
214
215
216
217
218       val (mod) : int -> int -> int
219
220
221
222
223       val abs : int -> int
224
225
226
227
228       val max_int : int
229
230
231
232
233       val min_int : int
234
235
236
237
238       val (land) : int -> int -> int
239
240
241
242
243       val (lor) : int -> int -> int
244
245
246
247
248       val (lxor) : int -> int -> int
249
250
251
252
253       val lnot : int -> int
254
255
256
257
258       val (lsl) : int -> int -> int
259
260
261
262
263       val (lsr) : int -> int -> int
264
265
266
267
268       val (asr) : int -> int -> int
269
270
271
272
273       val (~-.)  : float -> float
274
275
276
277
278       val (~+.)  : float -> float
279
280
281
282
283       val (+.)  : float -> float -> float
284
285
286
287
288       val (-.)  : float -> float -> float
289
290
291
292
293       val ( *. ) : float -> float -> float
294
295
296
297
298       val (/.)  : float -> float -> float
299
300
301
302
303       val ( ** ) : float -> float -> float
304
305
306
307
308       val sqrt : float -> float
309
310
311
312
313       val exp : float -> float
314
315
316
317
318       val log : float -> float
319
320
321
322
323       val log10 : float -> float
324
325
326
327
328       val expm1 : float -> float
329
330
331
332
333       val log1p : float -> float
334
335
336
337
338       val cos : float -> float
339
340
341
342
343       val sin : float -> float
344
345
346
347
348       val tan : float -> float
349
350
351
352
353       val acos : float -> float
354
355
356
357
358       val asin : float -> float
359
360
361
362
363       val atan : float -> float
364
365
366
367
368       val atan2 : float -> float -> float
369
370
371
372
373       val hypot : float -> float -> float
374
375
376
377
378       val cosh : float -> float
379
380
381
382
383       val sinh : float -> float
384
385
386
387
388       val tanh : float -> float
389
390
391
392
393       val ceil : float -> float
394
395
396
397
398       val floor : float -> float
399
400
401
402
403       val abs_float : float -> float
404
405
406
407
408       val copysign : float -> float -> float
409
410
411
412
413       val mod_float : float -> float -> float
414
415
416
417
418       val frexp : float -> float * int
419
420
421
422
423       val ldexp : float -> int -> float
424
425
426
427
428       val modf : float -> float * float
429
430
431
432
433       val float : int -> float
434
435
436
437
438       val float_of_int : int -> float
439
440
441
442
443       val truncate : float -> int
444
445
446
447
448       val int_of_float : float -> int
449
450
451
452
453       val infinity : float
454
455
456
457
458       val neg_infinity : float
459
460
461
462
463       val nan : float
464
465
466
467
468       val max_float : float
469
470
471
472
473       val min_float : float
474
475
476
477
478       val epsilon_float : float
479
480
481
482       type fpclass = fpclass =
483        | FP_normal
484        | FP_subnormal
485        | FP_zero
486        | FP_infinite
487        | FP_nan
488
489
490
491
492
493       val classify_float : float -> fpclass
494
495
496
497
498       val (^) : string -> string -> string
499
500
501
502
503       val int_of_char : char -> int
504
505
506
507
508       val char_of_int : int -> char
509
510
511
512
513       val ignore : 'a -> unit
514
515
516
517
518       val string_of_bool : bool -> string
519
520
521
522
523       val bool_of_string : string -> bool
524
525
526
527
528       val bool_of_string_opt : string -> bool option
529
530
531
532
533       val string_of_int : int -> string
534
535
536
537
538       val int_of_string : string -> int
539
540
541
542
543       val int_of_string_opt : string -> int option
544
545
546
547
548       val string_of_float : float -> string
549
550
551
552
553       val float_of_string : string -> float
554
555
556
557
558       val float_of_string_opt : string -> float option
559
560
561
562
563       val fst : 'a * 'b -> 'a
564
565
566
567
568       val snd : 'a * 'b -> 'b
569
570
571
572
573       val (@) : 'a list -> 'a list -> 'a list
574
575
576
577       type in_channel = in_channel
578
579
580
581
582       type out_channel = out_channel
583
584
585
586
587
588       val stdin : in_channel
589
590
591
592
593       val stdout : out_channel
594
595
596
597
598       val stderr : out_channel
599
600
601
602
603       val print_char : char -> unit
604
605
606
607
608       val print_string : string -> unit
609
610
611
612
613       val print_bytes : bytes -> unit
614
615
616
617
618       val print_int : int -> unit
619
620
621
622
623       val print_float : float -> unit
624
625
626
627
628       val print_endline : string -> unit
629
630
631
632
633       val print_newline : unit -> unit
634
635
636
637
638       val prerr_char : char -> unit
639
640
641
642
643       val prerr_string : string -> unit
644
645
646
647
648       val prerr_bytes : bytes -> unit
649
650
651
652
653       val prerr_int : int -> unit
654
655
656
657
658       val prerr_float : float -> unit
659
660
661
662
663       val prerr_endline : string -> unit
664
665
666
667
668       val prerr_newline : unit -> unit
669
670
671
672
673       val read_line : unit -> string
674
675
676
677
678       val read_int : unit -> int
679
680
681
682
683       val read_int_opt : unit -> int option
684
685
686
687
688       val read_float : unit -> float
689
690
691
692
693       val read_float_opt : unit -> float option
694
695
696
697       type open_flag = open_flag =
698        | Open_rdonly
699        | Open_wronly
700        | Open_append
701        | Open_creat
702        | Open_trunc
703        | Open_excl
704        | Open_binary
705        | Open_text
706        | Open_nonblock
707
708
709
710
711
712       val open_out : string -> out_channel
713
714
715
716
717       val open_out_bin : string -> out_channel
718
719
720
721
722       val open_out_gen : open_flag list -> int -> string -> out_channel
723
724
725
726
727       val flush : out_channel -> unit
728
729
730
731
732       val flush_all : unit -> unit
733
734
735
736
737       val output_char : out_channel -> char -> unit
738
739
740
741
742       val output_string : out_channel -> string -> unit
743
744
745
746
747       val output_bytes : out_channel -> bytes -> unit
748
749
750
751
752       val output : out_channel -> bytes -> int -> int -> unit
753
754
755
756
757       val output_substring : out_channel -> string -> int -> int -> unit
758
759
760
761
762       val output_byte : out_channel -> int -> unit
763
764
765
766
767       val output_binary_int : out_channel -> int -> unit
768
769
770
771
772       val output_value : out_channel -> 'a -> unit
773
774
775
776
777       val seek_out : out_channel -> int -> unit
778
779
780
781
782       val pos_out : out_channel -> int
783
784
785
786
787       val out_channel_length : out_channel -> int
788
789
790
791
792       val close_out : out_channel -> unit
793
794
795
796
797       val close_out_noerr : out_channel -> unit
798
799
800
801
802       val set_binary_mode_out : out_channel -> bool -> unit
803
804
805
806
807       val open_in : string -> in_channel
808
809
810
811
812       val open_in_bin : string -> in_channel
813
814
815
816
817       val open_in_gen : open_flag list -> int -> string -> in_channel
818
819
820
821
822       val input_char : in_channel -> char
823
824
825
826
827       val input_line : in_channel -> string
828
829
830
831
832       val input : in_channel -> bytes -> int -> int -> int
833
834
835
836
837       val really_input : in_channel -> bytes -> int -> int -> unit
838
839
840
841
842       val really_input_string : in_channel -> int -> string
843
844
845
846
847       val input_byte : in_channel -> int
848
849
850
851
852       val input_binary_int : in_channel -> int
853
854
855
856
857       val input_value : in_channel -> 'a
858
859
860
861
862       val seek_in : in_channel -> int -> unit
863
864
865
866
867       val pos_in : in_channel -> int
868
869
870
871
872       val in_channel_length : in_channel -> int
873
874
875
876
877       val close_in : in_channel -> unit
878
879
880
881
882       val close_in_noerr : in_channel -> unit
883
884
885
886
887       val set_binary_mode_in : in_channel -> bool -> unit
888
889
890
891       module LargeFile : (module LargeFile)
892
893
894
895
896       type 'a ref = 'a ref = {
897
898       mutable contents : 'a ;
899        }
900
901
902
903
904
905       val ref : 'a -> 'a ref
906
907
908
909
910       val (!)  : 'a ref -> 'a
911
912
913
914
915       val (:=) : 'a ref -> 'a -> unit
916
917
918
919
920       val incr : int ref -> unit
921
922
923
924
925       val decr : int ref -> unit
926
927
928
929       type ('a, 'b) result = ('a, 'b) result =
930        | Ok of 'a
931        | Error of 'b
932
933
934
935
936       type  ('a,  'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Cam‐
937       linternalFormatBasics.format6
938
939
940
941
942       type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
943
944
945
946
947       type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
948
949
950
951
952
953       val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
954
955
956
957
958       val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c,
959       'd, 'e, 'f) format6
960
961
962
963
964       val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h)
965       format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
966
967
968
969
970       val exit : int -> 'a
971
972
973
974
975       val at_exit : (unit -> unit) -> unit
976
977
978
979
980       val valid_float_lexem : string -> string
981
982
983
984
985       val do_at_exit : unit -> unit
986
987
988
989
990
991
992OCamldoc                          2019-07-30              Stdlib.Pervasives(3)
Impressum