~npalix/coccinelle/upstream

« back to all changes in this revision

Viewing changes to bundles/stdcompat/stdcompat-current/interfaces/4.08/stdlib.mli

  • Committer: Thierry Martinez
  • Date: 2019-08-20 13:37:04 UTC
  • Revision ID: git-v1:0214afad4a32c95349c2c5a38e37cea407c455d0
Update bundles

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
external raise : exn -> 'a = "%raise"
 
2
external raise_notrace : exn -> 'a = "%raise_notrace"
 
3
val invalid_arg : string -> 'a
 
4
val failwith : string -> 'a
 
5
exception Exit 
 
6
exception Match_failure of (string * int * int) 
 
7
exception Assert_failure of (string * int * int) 
 
8
exception Invalid_argument of string 
 
9
exception Failure of string 
 
10
exception Not_found 
 
11
exception Out_of_memory 
 
12
exception Stack_overflow 
 
13
exception Sys_error of string 
 
14
exception End_of_file 
 
15
exception Division_by_zero 
 
16
exception Sys_blocked_io 
 
17
exception Undefined_recursive_module of (string * int * int) 
 
18
external (=) : 'a -> 'a -> bool = "%equal"
 
19
external (<>) : 'a -> 'a -> bool = "%notequal"
 
20
external (<) : 'a -> 'a -> bool = "%lessthan"
 
21
external (>) : 'a -> 'a -> bool = "%greaterthan"
 
22
external (<=) : 'a -> 'a -> bool = "%lessequal"
 
23
external (>=) : 'a -> 'a -> bool = "%greaterequal"
 
24
external compare : 'a -> 'a -> int = "%compare"
 
25
val min : 'a -> 'a -> 'a
 
26
val max : 'a -> 'a -> 'a
 
27
external (==) : 'a -> 'a -> bool = "%eq"
 
28
external (!=) : 'a -> 'a -> bool = "%noteq"
 
29
external not : bool -> bool = "%boolnot"
 
30
external (&&) : bool -> bool -> bool = "%sequand"
 
31
external (&) : bool -> bool -> bool = "%sequand"
 
32
external (||) : bool -> bool -> bool = "%sequor"
 
33
external (or) : bool -> bool -> bool = "%sequor"
 
34
external __LOC__ : string = "%loc_LOC"
 
35
external __FILE__ : string = "%loc_FILE"
 
36
external __LINE__ : int = "%loc_LINE"
 
37
external __MODULE__ : string = "%loc_MODULE"
 
38
external __POS__ : (string * int * int * int) = "%loc_POS"
 
39
external __LOC_OF__ : 'a -> (string * 'a) = "%loc_LOC"
 
40
external __LINE_OF__ : 'a -> (int * 'a) = "%loc_LINE"
 
41
external __POS_OF__ : 'a -> ((string * int * int * int) * 'a) = "%loc_POS"
 
42
external (|>) : 'a -> ('a -> 'b) -> 'b = "%revapply"
 
43
external (@@) : ('a -> 'b) -> 'a -> 'b = "%apply"
 
44
external (~-) : int -> int = "%negint"
 
45
external (~+) : int -> int = "%identity"
 
46
external succ : int -> int = "%succint"
 
47
external pred : int -> int = "%predint"
 
48
external (+) : int -> int -> int = "%addint"
 
49
external (-) : int -> int -> int = "%subint"
 
50
external ( * ) : int -> int -> int = "%mulint"
 
51
external (/) : int -> int -> int = "%divint"
 
52
external (mod) : int -> int -> int = "%modint"
 
53
val abs : int -> int
 
54
val max_int : int
 
55
val min_int : int
 
56
external (land) : int -> int -> int = "%andint"
 
57
external (lor) : int -> int -> int = "%orint"
 
58
external (lxor) : int -> int -> int = "%xorint"
 
59
val lnot : int -> int
 
60
external (lsl) : int -> int -> int = "%lslint"
 
61
external (lsr) : int -> int -> int = "%lsrint"
 
62
external (asr) : int -> int -> int = "%asrint"
 
63
external (~-.) : float -> float = "%negfloat"
 
64
external (~+.) : float -> float = "%identity"
 
65
external (+.) : float -> float -> float = "%addfloat"
 
66
external (-.) : float -> float -> float = "%subfloat"
 
67
external ( *. ) : float -> float -> float = "%mulfloat"
 
68
external (/.) : float -> float -> float = "%divfloat"
 
69
external ( ** ) : float -> float -> float = "caml_power_float" "pow"[@@unboxed
 
70
                                                                    ]
 
71
[@@noalloc ]
 
72
external sqrt : float -> float = "caml_sqrt_float" "sqrt"[@@unboxed ]
 
73
[@@noalloc ]
 
74
external exp : float -> float = "caml_exp_float" "exp"[@@unboxed ][@@noalloc
 
75
                                                                    ]
 
76
external log : float -> float = "caml_log_float" "log"[@@unboxed ][@@noalloc
 
77
                                                                    ]
 
78
external log10 : float -> float = "caml_log10_float" "log10"[@@unboxed ]
 
79
[@@noalloc ]
 
80
external expm1 : float -> float = "caml_expm1_float" "caml_expm1"[@@unboxed ]
 
81
[@@noalloc ]
 
82
external log1p : float -> float = "caml_log1p_float" "caml_log1p"[@@unboxed ]
 
83
[@@noalloc ]
 
84
external cos : float -> float = "caml_cos_float" "cos"[@@unboxed ][@@noalloc
 
85
                                                                    ]
 
86
external sin : float -> float = "caml_sin_float" "sin"[@@unboxed ][@@noalloc
 
87
                                                                    ]
 
88
external tan : float -> float = "caml_tan_float" "tan"[@@unboxed ][@@noalloc
 
89
                                                                    ]
 
90
external acos : float -> float = "caml_acos_float" "acos"[@@unboxed ]
 
91
[@@noalloc ]
 
92
external asin : float -> float = "caml_asin_float" "asin"[@@unboxed ]
 
93
[@@noalloc ]
 
94
external atan : float -> float = "caml_atan_float" "atan"[@@unboxed ]
 
95
[@@noalloc ]
 
96
external atan2 : float -> float -> float = "caml_atan2_float" "atan2"
 
97
[@@unboxed ][@@noalloc ]
 
98
external hypot : float -> float -> float = "caml_hypot_float" "caml_hypot"
 
99
[@@unboxed ][@@noalloc ]
 
100
external cosh : float -> float = "caml_cosh_float" "cosh"[@@unboxed ]
 
101
[@@noalloc ]
 
102
external sinh : float -> float = "caml_sinh_float" "sinh"[@@unboxed ]
 
103
[@@noalloc ]
 
104
external tanh : float -> float = "caml_tanh_float" "tanh"[@@unboxed ]
 
105
[@@noalloc ]
 
106
external ceil : float -> float = "caml_ceil_float" "ceil"[@@unboxed ]
 
107
[@@noalloc ]
 
108
external floor : float -> float = "caml_floor_float" "floor"[@@unboxed ]
 
109
[@@noalloc ]
 
110
external abs_float : float -> float = "%absfloat"
 
111
external copysign :
 
112
  float -> float -> float = "caml_copysign_float" "caml_copysign"[@@unboxed ]
 
113
[@@noalloc ]
 
114
external mod_float : float -> float -> float = "caml_fmod_float" "fmod"
 
115
[@@unboxed ][@@noalloc ]
 
116
external frexp : float -> (float * int) = "caml_frexp_float"
 
117
external ldexp :
 
118
  ((float)[@unboxed ]) -> ((int)[@untagged ]) -> ((float)[@unboxed ]) =
 
119
    "caml_ldexp_float" "caml_ldexp_float_unboxed"[@@noalloc ]
 
120
external modf : float -> (float * float) = "caml_modf_float"
 
121
external float : int -> float = "%floatofint"
 
122
external float_of_int : int -> float = "%floatofint"
 
123
external truncate : float -> int = "%intoffloat"
 
124
external int_of_float : float -> int = "%intoffloat"
 
125
val infinity : float
 
126
val neg_infinity : float
 
127
val nan : float
 
128
val max_float : float
 
129
val min_float : float
 
130
val epsilon_float : float
 
131
type fpclass =
 
132
  | FP_normal 
 
133
  | FP_subnormal 
 
134
  | FP_zero 
 
135
  | FP_infinite 
 
136
  | FP_nan 
 
137
external classify_float :
 
138
  ((float)[@unboxed ]) -> fpclass = "caml_classify_float"
 
139
    "caml_classify_float_unboxed"[@@noalloc ]
 
140
val (^) : string -> string -> string
 
141
external int_of_char : char -> int = "%identity"
 
142
val char_of_int : int -> char
 
143
external ignore : 'a -> unit = "%ignore"
 
144
val string_of_bool : bool -> string
 
145
val bool_of_string_opt : string -> bool option
 
146
val bool_of_string : string -> bool
 
147
val string_of_int : int -> string
 
148
val int_of_string_opt : string -> int option
 
149
external int_of_string : string -> int = "caml_int_of_string"
 
150
val string_of_float : float -> string
 
151
val float_of_string_opt : string -> float option
 
152
external float_of_string : string -> float = "caml_float_of_string"
 
153
external fst : ('a * 'b) -> 'a = "%field0"
 
154
external snd : ('a * 'b) -> 'b = "%field1"
 
155
val (@) : 'a list -> 'a list -> 'a list
 
156
type in_channel
 
157
type out_channel
 
158
val stdin : in_channel
 
159
val stdout : out_channel
 
160
val stderr : out_channel
 
161
val print_char : char -> unit
 
162
val print_string : string -> unit
 
163
val print_bytes : bytes -> unit
 
164
val print_int : int -> unit
 
165
val print_float : float -> unit
 
166
val print_endline : string -> unit
 
167
val print_newline : unit -> unit
 
168
val prerr_char : char -> unit
 
169
val prerr_string : string -> unit
 
170
val prerr_bytes : bytes -> unit
 
171
val prerr_int : int -> unit
 
172
val prerr_float : float -> unit
 
173
val prerr_endline : string -> unit
 
174
val prerr_newline : unit -> unit
 
175
val read_line : unit -> string
 
176
val read_int_opt : unit -> int option
 
177
val read_int : unit -> int
 
178
val read_float_opt : unit -> float option
 
179
val read_float : unit -> float
 
180
type open_flag =
 
181
  | Open_rdonly 
 
182
  | Open_wronly 
 
183
  | Open_append 
 
184
  | Open_creat 
 
185
  | Open_trunc 
 
186
  | Open_excl 
 
187
  | Open_binary 
 
188
  | Open_text 
 
189
  | Open_nonblock 
 
190
val open_out : string -> out_channel
 
191
val open_out_bin : string -> out_channel
 
192
val open_out_gen : open_flag list -> int -> string -> out_channel
 
193
val flush : out_channel -> unit
 
194
val flush_all : unit -> unit
 
195
val output_char : out_channel -> char -> unit
 
196
val output_string : out_channel -> string -> unit
 
197
val output_bytes : out_channel -> bytes -> unit
 
198
val output : out_channel -> bytes -> int -> int -> unit
 
199
val output_substring : out_channel -> string -> int -> int -> unit
 
200
val output_byte : out_channel -> int -> unit
 
201
val output_binary_int : out_channel -> int -> unit
 
202
val output_value : out_channel -> 'a -> unit
 
203
val seek_out : out_channel -> int -> unit
 
204
val pos_out : out_channel -> int
 
205
val out_channel_length : out_channel -> int
 
206
val close_out : out_channel -> unit
 
207
val close_out_noerr : out_channel -> unit
 
208
val set_binary_mode_out : out_channel -> bool -> unit
 
209
val open_in : string -> in_channel
 
210
val open_in_bin : string -> in_channel
 
211
val open_in_gen : open_flag list -> int -> string -> in_channel
 
212
val input_char : in_channel -> char
 
213
val input_line : in_channel -> string
 
214
val input : in_channel -> bytes -> int -> int -> int
 
215
val really_input : in_channel -> bytes -> int -> int -> unit
 
216
val really_input_string : in_channel -> int -> string
 
217
val input_byte : in_channel -> int
 
218
val input_binary_int : in_channel -> int
 
219
val input_value : in_channel -> 'a
 
220
val seek_in : in_channel -> int -> unit
 
221
val pos_in : in_channel -> int
 
222
val in_channel_length : in_channel -> int
 
223
val close_in : in_channel -> unit
 
224
val close_in_noerr : in_channel -> unit
 
225
val set_binary_mode_in : in_channel -> bool -> unit
 
226
module LargeFile :
 
227
sig
 
228
  val seek_out : out_channel -> int64 -> unit
 
229
  val pos_out : out_channel -> int64
 
230
  val out_channel_length : out_channel -> int64
 
231
  val seek_in : in_channel -> int64 -> unit
 
232
  val pos_in : in_channel -> int64
 
233
  val in_channel_length : in_channel -> int64
 
234
end
 
235
type 'a ref = {
 
236
  mutable contents: 'a }
 
237
external ref : 'a -> 'a ref = "%makemutable"
 
238
external (!) : 'a ref -> 'a = "%field0"
 
239
external (:=) : 'a ref -> 'a -> unit = "%setfield0"
 
240
external incr : int ref -> unit = "%incr"
 
241
external decr : int ref -> unit = "%decr"
 
242
type ('a, 'b) result =
 
243
  | Ok of 'a 
 
244
  | Error of 'b 
 
245
type ('a, 'b, 'c, 'd, 'e, 'f) format6 =
 
246
  ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
 
247
type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
 
248
type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
 
249
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
 
250
external format_of_string :
 
251
  ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6 =
 
252
    "%identity"
 
253
val (^^) :
 
254
  ('a, 'b, 'c, 'd, 'e, 'f) format6 ->
 
255
    ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) format6
 
256
val exit : int -> 'a
 
257
val at_exit : (unit -> unit) -> unit
 
258
val valid_float_lexem : string -> string
 
259
val unsafe_really_input : in_channel -> bytes -> int -> int -> unit
 
260
val do_at_exit : unit -> unit
 
261
module Arg = Arg
 
262
module Array = Array
 
263
module ArrayLabels = ArrayLabels
 
264
module Bigarray = Bigarray
 
265
module Bool = Bool
 
266
module Buffer = Buffer
 
267
module Bytes = Bytes
 
268
module BytesLabels = BytesLabels
 
269
module Callback = Callback
 
270
module Char = Char
 
271
module Complex = Complex
 
272
module Digest = Digest
 
273
module Ephemeron = Ephemeron
 
274
module Filename = Filename
 
275
module Float = Float
 
276
module Format = Format
 
277
module Fun = Fun
 
278
module Gc = Gc
 
279
module Genlex = Genlex
 
280
module Hashtbl = Hashtbl
 
281
module Int = Int
 
282
module Int32 = Int32
 
283
module Int64 = Int64
 
284
module Lazy = Lazy
 
285
module Lexing = Lexing
 
286
module List = List
 
287
module ListLabels = ListLabels
 
288
module Map = Map
 
289
module Marshal = Marshal
 
290
module MoreLabels = MoreLabels
 
291
module Nativeint = Nativeint
 
292
module Obj = Obj
 
293
module Oo = Oo
 
294
module Option = Option
 
295
module Parsing = Parsing
 
296
module Pervasives = Pervasives
 
297
module Printexc = Printexc
 
298
module Printf = Printf
 
299
module Queue = Queue
 
300
module Random = Random
 
301
module Result = Result
 
302
module Scanf = Scanf
 
303
module Seq = Seq
 
304
module Set = Set
 
305
module Spacetime = Spacetime
 
306
module Stack = Stack
 
307
module StdLabels = StdLabels
 
308
module Stream = Stream
 
309
module String = String
 
310
module StringLabels = StringLabels
 
311
module Sys = Sys
 
312
module Uchar = Uchar
 
313
module Weak = Weak