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

NAME

6       Pervasives - no description
7

Module

9       Module   Pervasives
10

Documentation

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