include module type of sig ... end with module Filename := Caml.Filename with module Int := Base.Int with module Int32 := Base.Int32 with module Int64 := Base.Int64 with module Map := Base.Map with module Marshal := Caml.Marshal with module Nativeint := Base.Nativeint
val raise_notrace : exn -> 'a
exception
Exit
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val (&) : bool -> bool -> bool
val or : bool -> bool -> bool
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (mod) : int -> int -> int
val max_int : int
val min_int : int
val (~+.) : float -> float
val sqrt : float -> float
val exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type nonrec fpclass
= Stdlib.fpclass
=
| FP_normal |
| FP_subnormal |
| FP_zero |
| FP_infinite |
| FP_nan |
val classify_float : float -> fpclass
val int_of_char : char -> int
val char_of_int : int -> char
val string_of_bool : bool -> string
val bool_of_string_opt : string -> bool option
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string_opt : string -> int option
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string_opt : string -> float option
val float_of_string : string -> float
type nonrec in_channel
= Stdlib.in_channel
type nonrec out_channel
= Stdlib.out_channel
val stdin : in_channel
val stdout : out_channel
val stderr : out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int_opt : unit -> int option
val read_int : unit -> int
val read_float_opt : unit -> float option
val read_float : unit -> float
type nonrec open_flag
= Stdlib.open_flag
=
| Open_rdonly |
| Open_wronly |
| Open_append |
| Open_creat |
| Open_trunc |
| Open_excl |
| Open_binary |
| Open_text |
| Open_nonblock |
val open_out : string -> out_channel
val open_out_bin : string -> out_channel
val open_out_gen : open_flag list -> int -> string -> out_channel
val flush : out_channel -> unit
val flush_all : unit -> unit
val output_char : out_channel -> char -> unit
val output_string : out_channel -> string -> unit
val output_bytes : out_channel -> bytes -> unit
val output : out_channel -> bytes -> int -> int -> unit
val output_substring : out_channel -> string -> int -> int -> unit
val output_byte : out_channel -> int -> unit
val output_binary_int : out_channel -> int -> unit
val output_value : out_channel -> 'a -> unit
val seek_out : out_channel -> int -> unit
val pos_out : out_channel -> int
val out_channel_length : out_channel -> int
val close_out : out_channel -> unit
val close_out_noerr : out_channel -> unit
val set_binary_mode_out : out_channel -> bool -> unit
val open_in : string -> in_channel
val open_in_bin : string -> in_channel
val open_in_gen : open_flag list -> int -> string -> in_channel
val input_char : in_channel -> char
val input_line : in_channel -> string
val input : in_channel -> bytes -> int -> int -> int
val really_input : in_channel -> bytes -> int -> int -> unit
val really_input_string : in_channel -> int -> string
val input_byte : in_channel -> int
val input_binary_int : in_channel -> int
val input_value : in_channel -> 'a
val seek_in : in_channel -> int -> unit
val pos_in : in_channel -> int
val in_channel_length : in_channel -> int
val close_in : in_channel -> unit
val close_in_noerr : in_channel -> unit
val set_binary_mode_in : in_channel -> bool -> unit
module LargeFile = Stdlib.LargeFile
val incr : int Stdlib.ref -> unit
val decr : int Stdlib.ref -> unit
type nonrec ('a, 'b) result
= ('a, 'b) Stdlib.result
=
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> ('f, 'b, 'c, 'e, 'g, 'h) Stdlib.format6 -> ('a, 'b, 'c, 'd, 'g, 'h) Stdlib.format6
val exit : int -> 'a
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val unsafe_really_input : in_channel -> bytes -> int -> int -> unit
val do_at_exit : unit -> unit
module ArrayLabels = Stdlib.ArrayLabels
module BytesLabels = Stdlib.BytesLabels
module Callback = Stdlib.Callback
module Complex = Stdlib.Complex
module Digest = Stdlib.Digest
module Ephemeron = Stdlib.Ephemeron
module Filename = Stdlib.Filename
module Genlex = Stdlib.Genlex
module ListLabels = Stdlib.ListLabels
module Marshal = Stdlib.Marshal
module MoreLabels = Stdlib.MoreLabels
module Parsing = Stdlib.Parsing
module Pervasives = Stdlib.Pervasives
module Printexc = Stdlib.Printexc
module Scanf = Stdlib.Scanf
module Spacetime = Stdlib.Spacetime
module StdLabels = Stdlib.StdLabels
module Stream = Stdlib.Stream
module StringLabels = Stdlib.StringLabels
module Weak = Stdlib.Weak
exception
Not_found
module Polymorphic_compare = Poly
module type T = sig ... end
module type T1 = sig ... end
module type T2 = sig ... end
module type T3 = sig ... end
val lazy_t_sexp_grammar : Base__Sexp.Private.Raw_grammar.t
type 'a array
= 'a Array.t
val compare_array : ('a -> 'a -> int) -> 'a array -> 'a array -> int
val equal_array : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
val array_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a array
val sexp_of_array : ('a -> Base.Sexp.t) -> 'a array -> Base.Sexp.t
val array_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type bool
= Bool.t
val compare_bool : bool -> bool -> int
val equal_bool : bool -> bool -> bool
val hash_fold_bool : Base.Hash.state -> bool -> Base.Hash.state
val hash_bool : bool -> Base.Hash.hash_value
val bool_of_sexp : Base.Sexp.t -> bool
val sexp_of_bool : bool -> Base.Sexp.t
val bool_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type char
= Char.t
val compare_char : char -> char -> int
val equal_char : char -> char -> bool
val hash_fold_char : Base.Hash.state -> char -> Base.Hash.state
val hash_char : char -> Base.Hash.hash_value
val char_of_sexp : Base.Sexp.t -> char
val sexp_of_char : char -> Base.Sexp.t
val char_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type exn
= Exn.t
val sexp_of_exn : exn -> Base.Sexp.t
type float
= Float.t
val compare_float : float -> float -> int
val equal_float : float -> float -> bool
val hash_fold_float : Base.Hash.state -> float -> Base.Hash.state
val hash_float : float -> Base.Hash.hash_value
val float_of_sexp : Base.Sexp.t -> float
val sexp_of_float : float -> Base.Sexp.t
val float_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type int
= Int.t
val compare_int : int -> int -> int
val equal_int : int -> int -> bool
val hash_fold_int : Base.Hash.state -> int -> Base.Hash.state
val hash_int : int -> Base.Hash.hash_value
val int_of_sexp : Base.Sexp.t -> int
val sexp_of_int : int -> Base.Sexp.t
val int_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type int32
= Int32.t
val compare_int32 : int32 -> int32 -> int
val equal_int32 : int32 -> int32 -> bool
val hash_fold_int32 : Base.Hash.state -> int32 -> Base.Hash.state
val hash_int32 : int32 -> Base.Hash.hash_value
val int32_of_sexp : Base.Sexp.t -> int32
val sexp_of_int32 : int32 -> Base.Sexp.t
val int32_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type int64
= Int64.t
val compare_int64 : int64 -> int64 -> int
val equal_int64 : int64 -> int64 -> bool
val hash_fold_int64 : Base.Hash.state -> int64 -> Base.Hash.state
val hash_int64 : int64 -> Base.Hash.hash_value
val int64_of_sexp : Base.Sexp.t -> int64
val sexp_of_int64 : int64 -> Base.Sexp.t
val int64_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type 'a list
= 'a List.t
val compare_list : ('a -> 'a -> int) -> 'a list -> 'a list -> int
val equal_list : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val hash_fold_list : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a list -> Base.Hash.state
val list_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a list
val sexp_of_list : ('a -> Base.Sexp.t) -> 'a list -> Base.Sexp.t
val list_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type nativeint
= Nativeint.t
val compare_nativeint : nativeint -> nativeint -> int
val equal_nativeint : nativeint -> nativeint -> bool
val hash_fold_nativeint : Base.Hash.state -> nativeint -> Base.Hash.state
val hash_nativeint : nativeint -> Base.Hash.hash_value
val nativeint_of_sexp : Base.Sexp.t -> nativeint
val sexp_of_nativeint : nativeint -> Base.Sexp.t
val nativeint_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type 'a option
= 'a Option.t
val compare_option : ('a -> 'a -> int) -> 'a option -> 'a option -> int
val equal_option : ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
val hash_fold_option : (Base.Hash.state -> 'a -> Base.Hash.state) -> Base.Hash.state -> 'a option -> Base.Hash.state
val option_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a option
val sexp_of_option : ('a -> Base.Sexp.t) -> 'a option -> Base.Sexp.t
val option_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type 'a ref
= 'a Ref.t
val compare_ref : ('a -> 'a -> int) -> 'a ref -> 'a ref -> int
val equal_ref : ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
val ref_of_sexp : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a ref
val sexp_of_ref : ('a -> Base.Sexp.t) -> 'a ref -> Base.Sexp.t
val ref_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type string
= String.t
val compare_string : string -> string -> int
val equal_string : string -> string -> bool
val hash_fold_string : Base.Hash.state -> string -> Base.Hash.state
val hash_string : string -> Base.Hash.hash_value
val string_of_sexp : Base.Sexp.t -> string
val sexp_of_string : string -> Base.Sexp.t
val string_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type bytes
= Bytes.t
val compare_bytes : bytes -> bytes -> int
val equal_bytes : bytes -> bytes -> bool
val bytes_of_sexp : Base.Sexp.t -> bytes
val sexp_of_bytes : bytes -> Base.Sexp.t
val bytes_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type unit
= Unit.t
val compare_unit : unit -> unit -> int
val equal_unit : unit -> unit -> bool
val hash_fold_unit : Base.Hash.state -> unit -> Base.Hash.state
val hash_unit : unit -> Base.Hash.hash_value
val unit_of_sexp : Base.Sexp.t -> unit
val sexp_of_unit : unit -> Base.Sexp.t
val unit_sexp_grammar : Base.Sexp.Private.Raw_grammar.t
type nonrec ('a, 'b, 'c) format
= ('a, 'b, 'c) Stdlib.format
type nonrec ('a, 'b, 'c, 'd) format4
= ('a, 'b, 'c, 'd) Stdlib.format4
type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6
= ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6
type 'a sexp_array
= 'a array
type 'a sexp_list
= 'a list
type 'a sexp_opaque
= 'a
type 'a sexp_option
= 'a option
val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t
val (+) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (-) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (*) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (~-) : Base__Int.t -> Base__Int.t
val (**) : Base__Int.t -> Base__Int.t -> Base__Int.t
val abs : Base__Int.t -> Base__Int.t
val neg : Base__Int.t -> Base__Int.t
val zero : Base__Int.t
val (%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (//) : Base__Int.t -> Base__Int.t -> float
val (land) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lxor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lnot) : Base__Int.t -> Base__Int.t
val (lsl) : Base__Int.t -> int -> Base__Int.t
val (asr) : Base__Int.t -> int -> Base__Int.t
val (lsr) : Base__Int.t -> int -> Base__Int.t
val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
val (+.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (-.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (*.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (/.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (**.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (~-.) : Base__Float.t -> Base__Float.t
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val ignore : 'a -> unit
val (^) : String.t -> String.t -> String.t
val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (:=) : 'a ref -> 'a -> unit
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val raise : exn -> 'a
val failwith : string -> 'a
val invalid_arg : string -> 'a
val raise_s : Base.Sexp.t -> 'a
val phys_equal : 'a -> 'a -> bool
val force : 'a Lazy.t -> 'a
exception
Not_found_s of Sexplib0.Sexp.t
module Int32 : sig ... end
module Int64 : sig ... end
val (**) : float -> float -> float
val (@@) : ('a -> 'b) -> 'a -> 'b
val (mod) : int -> int -> int
val at_exit : (unit -> unit) -> unit
val ceil : float -> float
val floor : float -> float
val concat : ?sep:String.t -> String.t list -> String.t
val error_s : Base.Sexp.t -> 'a Or_error.t
val fprintf : Out_channel.t -> ('a, Out_channel.t, Base.unit) Base.format -> 'a
val ok_exn : 'a Or_error.t -> 'a
val printf : ('a, Out_channel.t, Base.unit) Base.format -> 'a
val sprintf : ('a, unit, string) Stdlib.format -> 'a
val print_s : Sexplib0.Sexp.t -> Base.unit