Pervasives (melange.Stdlib.Pervasives)

let raise: exn => 'a;

let raise_notrace: exn => 'a;

let invalid_arg: string => 'a;

let failwith: string => 'a;

exception Exit;

let (=): 'a => 'a => bool;

let (<>): 'a => 'a => bool;

let (<): 'a => 'a => bool;

let (>): 'a => 'a => bool;

let (<=): 'a => 'a => bool;

let (>=): 'a => 'a => bool;

let compare: 'a => 'a => int;

let min: 'a => 'a => 'a;

let max: 'a => 'a => 'a;

let (==): 'a => 'a => bool;

let (!=): 'a => 'a => bool;

let not: bool => bool;

let (&&): bool => bool => bool;

let (&): bool => bool => bool;

deprecated Use (&&) instead.

let (||): bool => bool => bool;

let or: bool => bool => bool;

deprecated Use (||) instead.

let __LOC__: string;

let __FILE__: string;

let __LINE__: int;

let __MODULE__: string;

let __POS__: (string, int, int, int);

let __LOC_OF__: 'a => (string, 'a);

let __LINE_OF__: 'a => (int, 'a);

let __POS_OF__: 'a => ((string, int, int, int), 'a);

let (|>): 'a => ('a => 'b) => 'b;

let (@@): ('a => 'b) => 'a => 'b;

let (~-): int => int;

let (~+): int => int;

let succ: int => int;

let pred: int => int;

let (+): int => int => int;

let (-): int => int => int;

let (*): int => int => int;

let (/): int => int => int;

let (mod): int => int => int;

let abs: int => int;

let max_int: int;

let min_int: int;

let (land): int => int => int;

let (lor): int => int => int;

let (lxor): int => int => int;

let lnot: int => int;

let (lsl): int => int => int;

let (lsr): int => int => int;

let (asr): int => int => int;

let (~-.): float => float;

let (~+.): float => float;

let (+.): float => float => float;

let (-.): float => float => float;

let (*.): float => float => float;

let (/.): float => float => float;

let (**): float => float => float;

let exp: float => float;

let acos: float => float;

let asin: float => float;

let atan: float => float;

let atan2: float => float => float;

let hypot: float => float => float;

let cos: float => float;

let cosh: float => float;

let acosh: float => float;

let log: float => float;

let log10: float => float;

let log1p: float => float;

let sin: float => float;

let sinh: float => float;

let asinh: float => float;

let sqrt: float => float;

let tan: float => float;

let tanh: float => float;

let atanh: float => float;

let ceil: float => float;

let floor: float => float;

let abs_float: float => float;

let copysign: float => float => float;

let mod_float: float => float => float;

let frexp: float => (float, int);

let ldexp: float => int => float;

let modf: float => (float, float);

let float: int => float;

let float_of_int: int => float;

let truncate: float => int;

let int_of_float: float => int;

let infinity: float;

let neg_infinity: float;

let nan: float;

let max_float: float;

let min_float: float;

let epsilon_float: float;

type nonrec fpclass = fpclass =

| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan

;

let classify_float: float => fpclass;

let (^): string => string => string;

let int_of_char: char => int;

let char_of_int: int => char;

let ignore: 'a => unit;

let string_of_bool: bool => string;

let bool_of_string: string => bool;

let bool_of_string_opt: string => option(bool);

let string_of_int: int => string;

let int_of_string: string => int;

let int_of_string_opt: string => option(int);

let string_of_float: float => string;

let float_of_string: string => float;

let float_of_string_opt: string => option(float);

let fst: ('a, 'b) => 'a;

let snd: ('a, 'b) => 'b;

let (@): list('a) => list('a) => list('a);

type nonrec in_channel = in_channel;

type nonrec out_channel = out_channel;

let stdin: in_channel;

let stdout: out_channel;

let stderr: out_channel;

let print_char: char => unit;

let print_string: string => unit;

let print_bytes: bytes => unit;

let print_int: int => unit;

let print_float: float => unit;

let print_endline: string => unit;

let print_newline: unit => unit;

let prerr_char: char => unit;

let prerr_string: string => unit;

let prerr_bytes: bytes => unit;

let prerr_int: int => unit;

let prerr_float: float => unit;

let prerr_endline: string => unit;

let prerr_newline: unit => unit;

let read_line: unit => string;

let read_int: unit => int;

let read_int_opt: unit => option(int);

let read_float: unit => float;

let read_float_opt: unit => option(float);

type nonrec open_flag = open_flag =

| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock

;

let open_out: string => out_channel;

let open_out_bin: string => out_channel;

let open_out_gen: list(open_flag) => int => string => out_channel;

let flush: out_channel => unit;

let flush_all: unit => unit;

let output_char: out_channel => char => unit;

let output_string: out_channel => string => unit;

let output_bytes: out_channel => bytes => unit;

let output: out_channel => bytes => int => int => unit;

let output_substring: out_channel => string => int => int => unit;

let output_byte: out_channel => int => unit;

let output_binary_int: out_channel => int => unit;

let output_value: out_channel => 'a => unit;

let seek_out: out_channel => int => unit;

let pos_out: out_channel => int;

let out_channel_length: out_channel => int;

let close_out: out_channel => unit;

let close_out_noerr: out_channel => unit;

let set_binary_mode_out: out_channel => bool => unit;

let open_in: string => in_channel;

let open_in_bin: string => in_channel;

let open_in_gen: list(open_flag) => int => string => in_channel;

let input_char: in_channel => char;

let input_line: in_channel => string;

let input: in_channel => bytes => int => int => int;

let really_input: in_channel => bytes => int => int => unit;

let really_input_string: in_channel => int => string;

let input_byte: in_channel => int;

let input_binary_int: in_channel => int;

let input_value: in_channel => 'a;

let seek_in: in_channel => int => unit;

let pos_in: in_channel => int;

let in_channel_length: in_channel => int;

let close_in: in_channel => unit;

let close_in_noerr: in_channel => unit;

let set_binary_mode_in: in_channel => bool => unit;

module LargeFile = LargeFile;

type nonrec ref('a) = ref('a) = {

mutable contents: 'a,

};

let ref: 'a => ref('a);

let (!): ref('a) => 'a;

let (:=): ref('a) => 'a => unit;

let incr: ref(int) => unit;

let decr: ref(int) => unit;

type nonrec result('a, 'b) = result('a, 'b) =

| Ok('a)
| Error('b)

;

type format6('a, 'b, 'c, 'd, 'e, 'f) =
  CamlinternalFormatBasics.format6('a, 'b, 'c, 'd, 'e, 'f);

type format4('a, 'b, 'c, 'd) = format6('a, 'b, 'c, 'c, 'c, 'd);

type format('a, 'b, 'c) = format4('a, 'b, 'c, 'c);

let string_of_format: format6('a, 'b, 'c, 'd, 'e, 'f) => string;

let format_of_string: 
  format6('a, 'b, 'c, 'd, 'e, 'f) =>
  format6('a, 'b, 'c, 'd, 'e, 'f);

let (^^): 
  format6('a, 'b, 'c, 'd, 'e, 'f) =>
  format6('f, 'b, 'c, 'e, 'g, 'h) =>
  format6('a, 'b, 'c, 'd, 'g, 'h);

let exit: int => 'a;

let at_exit: (unit => unit) => unit;

let valid_float_lexem: string => string;

let do_at_exit: unit => unit;