Prelude (hax-engine.Hax_engine.Prelude)

include module type of struct include Base end

val raise_notrace : exn -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.raise_notrace] instead

exception Exit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Referring to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Stdlib.Exit instead

exception Not_found

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Instead of raising [Not_found], consider using [raise_s] with an informative error message. If code needs to distinguish [Not_found] from other exceptions, please change it to handle both [Not_found] and [Not_found_s]. Then, instead of raising [Not_found], raise [Not_found_s] with an informative error message.

val (==) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [phys_equal] instead.

val (!=) : 'a -> 'a -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [not (phys_equal ...)] instead.

val __LOC__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__LOC__] instead

val __FILE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__FILE__] instead

val __LINE__ : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__LINE__] instead

val __MODULE__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__MODULE__] instead

val __POS__ : string * int * int * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__POS__] instead

val __FUNCTION__ : string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__FUNCTION__] instead

val __LOC_OF__ : 'a -> string * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__LOC_OF__] instead

val __LINE_OF__ : 'a -> int * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__LINE_OF__] instead

val __POS_OF__ : 'a -> (string * int * int * int) * 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.__POS_OF__] instead

val (~+) : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.( ~+ )] instead

val succ : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.succ] instead.

val pred : int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.pred] instead.

val (mod) : int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use (%), which has slightly different semantics, or Int.rem which is equivalent.

val max_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.max_value] instead.

val min_int : int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.min_value] instead.

val (~+.) : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.( ~+. )] instead

val sqrt : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sqrt] instead.

val exp : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.exp] instead.

val log : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log] instead.

val log10 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log10] instead.

val expm1 : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.expm1] instead.

val log1p : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.log1p] instead.

val cos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.cos] instead.

val sin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sin] instead.

val tan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.tan] instead.

val acos : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.acos] instead.

val asin : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.asin] instead.

val atan : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.atan] instead.

val atan2 : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.atan2] instead.

val hypot : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.hypot] instead.

val cosh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.cosh] instead.

val sinh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.sinh] instead.

val tanh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.tanh] instead.

val acosh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.acosh] instead.

val asinh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.asinh] instead.

val atanh : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.atanh] instead.

val ceil : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.round_up] instead.

val floor : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.round_down] instead.

val abs_float : float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.abs_float] instead

val copysign : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.copysign] instead.

val mod_float : float -> float -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.mod_float] instead.

val frexp : float -> float * int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.frexp] instead.

val ldexp : float -> int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.ldexp] instead.

val modf : float -> float * float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.modf] instead.

val float : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_int] instead.

val float_of_int : int -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_int] instead.

val truncate : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_float] instead.

val int_of_float : float -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_float] instead.

val infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.infinity] instead.

val neg_infinity : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.neg_infinity] instead.

val nan : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.nan] instead.

val max_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.max_finite_value] instead.

val min_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.min_positive_normal_value] instead.

val epsilon_float : float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.epsilon_float] instead.

type nonrec fpclass = Stdlib.fpclass =

| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Referring to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Stdlib.fpclass instead

val classify_float : float -> fpclass

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.classify] instead.

val int_of_char : char -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Char.to_int] instead.

val char_of_int : int -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Char.of_int_exn] instead.

val string_of_bool : bool -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Bool.to_string] instead.

val bool_of_string_opt : string -> bool option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.bool_of_string_opt] instead

val bool_of_string : string -> bool

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Bool.of_string] instead.

val string_of_int : int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.to_string] instead.

val int_of_string_opt : string -> int option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.int_of_string_opt] instead

val int_of_string : string -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.of_string] instead.

val string_of_float : float -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.to_string] instead.

val float_of_string_opt : string -> float option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.float_of_string_opt] instead

val float_of_string : string -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Float.of_string] instead.

type nonrec in_channel = Stdlib.in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.t] instead.

type nonrec out_channel = Stdlib.out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.t] instead.

val stdin : in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stdin] instead.

val stdout : out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stdout] instead.

val stderr : out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.stderr] instead.

val print_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stdout] instead.

val print_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stdout] instead.

val print_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes Stdio.stdout] instead.

val print_int : int -> unit

deprecated

val print_float : float -> unit

deprecated

val print_endline : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.print_endline] instead.

val print_newline : unit -> unit

deprecated

val prerr_char : char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char Stdio.stderr] instead.

val prerr_string : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string Stdio.stderr] instead.

val prerr_bytes : bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes Stdio.stderr] instead.

val prerr_int : int -> unit

deprecated

val prerr_float : float -> unit

deprecated

val prerr_endline : string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.prerr_endline] instead.

val prerr_newline : unit -> unit

deprecated

val read_line : unit -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val read_int_opt : unit -> int option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.read_int_opt] instead

val read_int : unit -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.read_int] instead

val read_float_opt : unit -> float option

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.read_float_opt] instead

val read_float : unit -> float

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.read_float] instead

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

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Referring to the stdlib directly is discouraged by Base. You should either use the equivalent functionality offered by Base, or if you really want to refer to the stdlib, use Stdlib.open_flag instead

val open_out : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_bin : string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.create] instead.

val open_out_gen : open_flag list -> int -> string -> out_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.open_out_gen] instead

val flush : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.flush] instead.

val flush_all : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.flush_all] instead

val output_char : out_channel -> char -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_char] instead.

val output_string : out_channel -> string -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_string] instead.

val output_bytes : out_channel -> bytes -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_bytes] instead.

val output : out_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_substring : out_channel -> string -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output] instead.

val output_byte : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_byte] instead.

val output_binary_int : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_binary_int] instead.

val output_value : out_channel -> 'a -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.output_value] instead.

val seek_out : out_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.seek] instead.

val pos_out : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.pos] instead.

val out_channel_length : out_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.length] instead.

val close_out : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val close_out_noerr : out_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.close] instead.

val set_binary_mode_out : out_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.Out_channel.set_binary_mode] instead.

val open_in : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_bin : string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.create] instead.

val open_in_gen : open_flag list -> int -> string -> in_channel

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.open_in_gen] instead

val input_char : in_channel -> char

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_char] instead.

val input_line : in_channel -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_line] instead.

val input : in_channel -> bytes -> int -> int -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input] instead.

val really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.really_input] instead.

val really_input_string : in_channel -> int -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is no equivalent functionality in Base or Stdio but you can use [Stdio.In_channel] instead. Alternatively, if you really want to refer the stdlib you can use [Stdlib.really_input_string].

val input_byte : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_byte] instead.

val input_binary_int : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.input_binary_int] instead.

val input_value : in_channel -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.unsafe_input_value] instead.

val seek_in : in_channel -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.seek] instead.

val pos_in : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.pos] instead.

val in_channel_length : in_channel -> int

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.length] instead.

val close_in : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val close_in_noerr : in_channel -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.close] instead.

val set_binary_mode_in : in_channel -> bool -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Stdio.In_channel.set_binary_mode] instead.

module LargeFile = Stdlib.LargeFile

val incr : int Stdlib.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.incr] instead.

val decr : int Stdlib.ref -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Int.decr] instead.

type nonrec (!'a, !'b) result = ('a, 'b) Stdlib.result =

| Ok of 'a
| Error of 'b

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. Use [Result.t] instead.

val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.string_of_format] instead

val format_of_string : 
  ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 ->
  ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.format_of_string] instead

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

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.( ^^ )] instead

val exit : int -> 'a

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.exit] instead

val at_exit : (unit -> unit) -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.at_exit] instead

val valid_float_lexem : string -> string

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.valid_float_lexem] instead

val unsafe_really_input : in_channel -> bytes -> int -> int -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.unsafe_really_input] instead

val do_at_exit : unit -> unit

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.do_at_exit] instead

val do_domain_local_at_exit : (unit -> unit) Stdlib.ref

deprecated [2016-09] this element comes from the stdlib distributed with OCaml. There is not equivalent functionality in Base or Stdio at the moment, so you need to use [Stdlib.do_domain_local_at_exit] instead

module Arg = Stdlib.Arg

module ArrayLabels = Stdlib.ArrayLabels

module BytesLabels = Stdlib.BytesLabels

module Callback = Stdlib.Callback

module Complex = Stdlib.Complex

module Condition = Stdlib.Condition

module Digest = Stdlib.Digest

module Domain = Stdlib.Domain

module Effect = Stdlib.Effect

module Ephemeron = Stdlib.Ephemeron

module Filename = Stdlib.Filename

module Format = Stdlib.Format

module Fun = Stdlib.Fun

module Gc = Stdlib.Gc

module ListLabels = Stdlib.ListLabels

module Marshal = Stdlib.Marshal

module MoreLabels = Stdlib.MoreLabels

module Mutex = Stdlib.Mutex

module Obj = Stdlib.Obj

module Oo = Stdlib.Oo

module Parsing = Stdlib.Parsing

module Printexc = Stdlib.Printexc

module Scanf = Stdlib.Scanf

module Semaphore = Stdlib.Semaphore

module Seq = Stdlib.Seq

module StdLabels = Stdlib.StdLabels

module StringLabels = Stdlib.StringLabels

module Type = Stdlib.Type

module Weak = Stdlib.Weak

module Applicative : sig ... end

module Array : sig ... end

module Avltree : sig ... end

module Backtrace : sig ... end

module Binary_search : sig ... end

module Binary_searchable : sig ... end

module Blit : sig ... end

module Bool : sig ... end

module Buffer : sig ... end

module Bytes : sig ... end

module Char : sig ... end

module Comparable : sig ... end

module Comparator : sig ... end

module Comparisons : sig ... end

module Container : sig ... end

module Either : sig ... end

module Equal : sig ... end

module Error : sig ... end

module Exn : sig ... end

module Field : sig ... end

module Float : sig ... end

module Floatable : sig ... end

module Fn : sig ... end

module Formatter : sig ... end

module Hash : sig ... end

module Hash_set : sig ... end

module Hashable : sig ... end

module Hasher : sig ... end

module Hashtbl : sig ... end

module Identifiable : sig ... end

module Indexed_container : sig ... end

module Info : sig ... end

module Int : sig ... end

module Int_conversions : sig ... end

module Int32 : sig ... end

module Int63 : sig ... end

module Int64 : sig ... end

module Intable : sig ... end

module Int_math : sig ... end

module Invariant : sig ... end

module Lazy : sig ... end

module Map : sig ... end

module Maybe_bound : sig ... end

module Monad : sig ... end

module Nativeint : sig ... end

module Nothing : sig ... end

module Option : sig ... end

module Option_array : sig ... end

module Or_error : sig ... end

module Ordered_collection_common : sig ... end

module Ordering : sig ... end

module Poly : sig ... end

module Popcount : sig ... end

module Pretty_printer : sig ... end

module Printf : sig ... end

module Linked_queue : sig ... end

module Queue : sig ... end

module Random : sig ... end

module Ref : sig ... end

module Result : sig ... end

module Sequence : sig ... end

module Set : sig ... end

module Sexpable : sig ... end

module Sign : sig ... end

module Sign_or_nan : sig ... end

module Source_code_position : sig ... end

module Stack : sig ... end

module Staged : sig ... end

module String : sig ... end

module Stringable : sig ... end

module Sys : sig ... end

module T : sig ... end

module Type_equal : sig ... end

module Uniform_array : sig ... end

module Unit : sig ... end

module Uchar : sig ... end

module Variant : sig ... end

module With_return : sig ... end

module Word_size : sig ... end

module type T = Base.T

module type T1 = Base.T1

module type T2 = Base.T2

module type T3 = Base.T3

module Sexp = Base.Sexp

module Exported_for_specific_uses = Base.Exported_for_specific_uses

module Export = Base.Export

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 globalize_array : ('a -> 'a) -> 'a array -> 'a array

val array_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a array

val sexp_of_array : ('a -> Sexplib0.Sexp.t) -> 'a array -> Sexplib0.Sexp.t

val array_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a array Sexplib0.Sexp_grammar.t

type bool = Bool.t

val compare_bool : bool -> bool -> int

val equal_bool : bool -> bool -> bool

val globalize_bool : bool -> bool

val hash_fold_bool : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  bool ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_bool : bool -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val bool_of_sexp : Sexplib0.Sexp.t -> bool

val sexp_of_bool : bool -> Sexplib0.Sexp.t

val bool_sexp_grammar : bool Sexplib0.Sexp_grammar.t

type char = Char.t

val compare_char : char -> char -> int

val equal_char : char -> char -> bool

val globalize_char : char -> char

val hash_fold_char : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  char ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_char : char -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val char_of_sexp : Sexplib0.Sexp.t -> char

val sexp_of_char : char -> Sexplib0.Sexp.t

val char_sexp_grammar : char Sexplib0.Sexp_grammar.t

type exn = Exn.t

val sexp_of_exn : exn -> Sexplib0.Sexp.t

type float = Float.t

val compare_float : float -> float -> int

val equal_float : float -> float -> bool

val globalize_float : float -> float

val hash_fold_float : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  float ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_float : float -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val float_of_sexp : Sexplib0.Sexp.t -> float

val sexp_of_float : float -> Sexplib0.Sexp.t

val float_sexp_grammar : float Sexplib0.Sexp_grammar.t

type int = Int.t

val compare_int : int -> int -> int

val equal_int : int -> int -> bool

val globalize_int : int -> int

val hash_fold_int : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int : int -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int_of_sexp : Sexplib0.Sexp.t -> int

val sexp_of_int : int -> Sexplib0.Sexp.t

val int_sexp_grammar : int Sexplib0.Sexp_grammar.t

type int32 = Int32.t

val compare_int32 : int32 -> int32 -> int

val equal_int32 : int32 -> int32 -> bool

val globalize_int32 : int32 -> int32

val hash_fold_int32 : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int32 ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int32 : int32 -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int32_of_sexp : Sexplib0.Sexp.t -> int32

val sexp_of_int32 : int32 -> Sexplib0.Sexp.t

val int32_sexp_grammar : int32 Sexplib0.Sexp_grammar.t

type int64 = Int64.t

val compare_int64 : int64 -> int64 -> int

val equal_int64 : int64 -> int64 -> bool

val globalize_int64 : int64 -> int64

val hash_fold_int64 : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  int64 ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_int64 : int64 -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val int64_of_sexp : Sexplib0.Sexp.t -> int64

val sexp_of_int64 : int64 -> Sexplib0.Sexp.t

val int64_sexp_grammar : int64 Sexplib0.Sexp_grammar.t

type !'a list = 'a {List}180.t

val compare_list : ('a -> 'a -> int) -> 'a list -> 'a list -> int

val equal_list : ('a -> 'a -> bool) -> 'a list -> 'a list -> bool

val globalize_list : ('a -> 'a) -> 'a list -> 'a list

val hash_fold_list : 
  (Base__.Ppx_hash_lib.Std.Hash.state ->
    'a ->
    Base__.Ppx_hash_lib.Std.Hash.state) ->
  Base__.Ppx_hash_lib.Std.Hash.state ->
  'a list ->
  Base__.Ppx_hash_lib.Std.Hash.state

val list_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a list

val sexp_of_list : ('a -> Sexplib0.Sexp.t) -> 'a list -> Sexplib0.Sexp.t

val list_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a list Sexplib0.Sexp_grammar.t

type nativeint = Nativeint.t

val compare_nativeint : nativeint -> nativeint -> int

val equal_nativeint : nativeint -> nativeint -> bool

val globalize_nativeint : nativeint -> nativeint

val hash_fold_nativeint : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  nativeint ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_nativeint : nativeint -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val nativeint_of_sexp : Sexplib0.Sexp.t -> nativeint

val sexp_of_nativeint : nativeint -> Sexplib0.Sexp.t

val nativeint_sexp_grammar : nativeint Sexplib0.Sexp_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 globalize_option : ('a -> 'a) -> 'a option -> 'a option

val hash_fold_option : 
  (Base__.Ppx_hash_lib.Std.Hash.state ->
    'a ->
    Base__.Ppx_hash_lib.Std.Hash.state) ->
  Base__.Ppx_hash_lib.Std.Hash.state ->
  'a option ->
  Base__.Ppx_hash_lib.Std.Hash.state

val option_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a option

val sexp_of_option : ('a -> Sexplib0.Sexp.t) -> 'a option -> Sexplib0.Sexp.t

val option_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a option Sexplib0.Sexp_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 globalize_ref : ('a -> 'a) -> 'a ref -> 'a ref

val ref_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a ref

val sexp_of_ref : ('a -> Sexplib0.Sexp.t) -> 'a ref -> Sexplib0.Sexp.t

val ref_sexp_grammar : 
  'a Sexplib0.Sexp_grammar.t ->
  'a ref Sexplib0.Sexp_grammar.t

type string = String.t

val compare_string : string -> string -> int

val equal_string : string -> string -> bool

val globalize_string : string -> string

val hash_fold_string : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  string ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_string : string -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val string_of_sexp : Sexplib0.Sexp.t -> string

val sexp_of_string : string -> Sexplib0.Sexp.t

val string_sexp_grammar : string Sexplib0.Sexp_grammar.t

type bytes = Bytes.t

val compare_bytes : bytes -> bytes -> int

val equal_bytes : bytes -> bytes -> bool

val globalize_bytes : bytes -> bytes

val bytes_of_sexp : Sexplib0.Sexp.t -> bytes

val sexp_of_bytes : bytes -> Sexplib0.Sexp.t

val bytes_sexp_grammar : bytes Sexplib0.Sexp_grammar.t

type unit = Unit.t

val compare_unit : unit -> unit -> int

val equal_unit : unit -> unit -> bool

val globalize_unit : unit -> unit

val hash_fold_unit : 
  Base__.Ppx_hash_lib.Std.Hash.state ->
  unit ->
  Base__.Ppx_hash_lib.Std.Hash.state

val hash_unit : unit -> Base__.Ppx_hash_lib.Std.Hash.hash_value

val unit_of_sexp : Sexplib0.Sexp.t -> unit

val sexp_of_unit : unit -> Sexplib0.Sexp.t

val unit_sexp_grammar : unit Sexplib0.Sexp_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

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 (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 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 (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 equal : int -> int -> bool

val ascending : int -> int -> int

val descending : int -> int -> int

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 -> 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

module Continue_or_stop : sig ... end

exception Not_found_s of Sexplib0.Sexp.t

include module type of struct include Utils end

val (<<) : ('a -> 'b) -> ('c -> 'd) -> 'e -> 'f

val (>>) : ('a -> 'b) -> ('c -> 'd) -> 'e -> 'f

val (&&&) : ('a -> 'b) -> ('a0 -> 'c) -> 'a1 -> 'b0 * 'c0

val (***) : ('a -> 'b) -> ('c -> 'd) -> ('a0 * 'c0) -> 'b0 * 'd0

val map_fst : ('a -> 'b) -> ('a * 'c) -> 'b * 'd

val map_snd : ('a -> 'b) -> ('c * 'a) -> 'd * 'b

val map_fst3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val map_snd3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val map_thd3 : ('a -> 'b) -> ('c * 'd * 'e) -> 'f * 'g * 'h

val fst3 : ('a * 'b * 'c) -> 'd

val snd3 : ('a * 'b * 'c) -> 'd

val thd3 : ('a * 'b * 'c) -> 'd

val curry : (('a * 'b) -> 'c) -> 'd -> 'e -> 'f

val uncurry : ('a -> 'b -> 'c) -> ('d * 'e) -> 'f

val curry3 : (('a * 'b * 'c) -> 'd) -> 'e -> 'f -> 'g -> 'h

val uncurry3 : ('a -> 'b -> 'c -> 'd) -> ('e * 'f * 'g) -> 'h

val tup2 : 'a -> 'b -> 'c * 'd

val swap : ('a * 'b) -> 'c * 'd

val apply : ('a -> 'b) -> 'c -> 'd

val let* : 'a Base.Option.t -> ('a -> 'b Base.Option.t) -> 'b Base.Option.t

val some_if_true : bool -> unit option

val let*? : Base.bool -> (Base.unit -> 'a Base.option) -> 'a0 Base.Option.t

let*? () = guard in body acts as a guard: if guard holds, then body is executed, otherwise None is returned.

val map_first_letter : 
  (Base.string -> Base.string) ->
  Base.string ->
  Base.String.t

val split_list_once : 
  equal:('a -> 'a -> bool) ->
  needle:'a Base.List.t ->
  acc:'b Base.List.t ->
  'a Base.List.t ->
  'c Base.List.t * 'd Base.List.t

val split_list : 
  equal:('a -> 'a -> bool) ->
  needle:'a Base.List.t ->
  'a0 Base.list ->
  'a1 Base.list Base.list

val first_letter : Base.String.t -> Base.String.t

val is_uppercase : Base.String.t -> bool

val is_lowercase : Base.String.t -> bool

val start_uppercase : Base.String.t -> bool

val start_lowercase : Base.String.t -> bool

val string_to_int : string -> Base.Int.t option

val split_str : Base.string -> on:Base.string -> Base.string Base.list

val last_init : 'a Base.list -> ('a0 Base.list * 'a0) Base.option

val inits : 'a Base.list -> ('a0 Base.list * 'a1) Base.list

val sequence : 'a Base.option Base.list -> 'a0 Base.list Base.option

val (<|>) : 'a option -> (unit -> 'b option) -> 'b option

val tabsize : int

val newline_indent : Base__Int.t -> Base.string

module MyInt64 = Utils.MyInt64

include sig ... end

val tempfile_path : suffix:Base.string -> Base.string

Generates a temporary file path that ends with `suffix`

module List = Utils.List

include module type of struct include Ppx_yojson_conv_lib.Yojson_conv.Primitives end

val yojson_of_unit : unit -> Yojson.Safe.t

val yojson_of_bool : bool -> Yojson.Safe.t

val yojson_of_string : string -> Yojson.Safe.t

val yojson_of_bytes : bytes -> Yojson.Safe.t

val yojson_of_char : char -> Yojson.Safe.t

val yojson_of_int : int -> Yojson.Safe.t

val yojson_of_float : float -> Yojson.Safe.t

val yojson_of_int32 : int32 -> Yojson.Safe.t

val yojson_of_int64 : int64 -> Yojson.Safe.t

val yojson_of_nativeint : nativeint -> Yojson.Safe.t

val yojson_of_ref : ('a -> Yojson.Safe.t) -> 'a Stdlib.ref -> Yojson.Safe.t

val yojson_of_lazy_t : ('a -> Yojson.Safe.t) -> 'a lazy_t -> Yojson.Safe.t

val yojson_of_option : ('a -> Yojson.Safe.t) -> 'a option -> Yojson.Safe.t

val yojson_of_list : ('a -> Yojson.Safe.t) -> 'a list -> Yojson.Safe.t

val yojson_of_array : ('a -> Yojson.Safe.t) -> 'a array -> Yojson.Safe.t

val yojson_of_hashtbl : 
  ('a -> Yojson.Safe.t) ->
  ('b -> Yojson.Safe.t) ->
  ('a, 'b) Stdlib.Hashtbl.t ->
  Yojson.Safe.t

val unit_of_yojson : Yojson.Safe.t -> unit

val bool_of_yojson : Yojson.Safe.t -> bool

val string_of_yojson : Yojson.Safe.t -> string

val bytes_of_yojson : Yojson.Safe.t -> bytes

val char_of_yojson : Yojson.Safe.t -> char

val int_of_yojson : Yojson.Safe.t -> int

val float_of_yojson : Yojson.Safe.t -> float

val int32_of_yojson : Yojson.Safe.t -> int32

val int64_of_yojson : Yojson.Safe.t -> int64

val nativeint_of_yojson : Yojson.Safe.t -> nativeint

val ref_of_yojson : (Yojson.Safe.t -> 'a) -> Yojson.Safe.t -> 'a Stdlib.ref

val lazy_t_of_yojson : (Yojson.Safe.t -> 'a) -> Yojson.Safe.t -> 'a lazy_t

val option_of_yojson : (Yojson.Safe.t -> 'a) -> Yojson.Safe.t -> 'a option

val list_of_yojson : (Yojson.Safe.t -> 'a) -> Yojson.Safe.t -> 'a list

val array_of_yojson : (Yojson.Safe.t -> 'a) -> Yojson.Safe.t -> 'a array

val hashtbl_of_yojson : 
  (Yojson.Safe.t -> 'a) ->
  (Yojson.Safe.t -> 'b) ->
  Yojson.Safe.t ->
  ('a, 'b) Stdlib.Hashtbl.t