Up – infer » IStdlib » IStdinclude module type of struct include Core end
module Applicative : sig ... end
module Array : sig ... end
module Avltree : sig ... end
module Backtrace : sig ... end
module Bigbuffer : sig ... end
module Bigstring : sig ... end
module Bigsubstring : sig ... end
module Bin_prot : sig ... end
module Binable : sig ... end
module Binary_search : sig ... end
module Binary_searchable : sig ... end
module Blang : sig ... end
module Blit : sig ... end
module Bool : sig ... end
module Bounded_index : sig ... end
module Buffer = Base .Buffer
module Byte_units : sig ... end
module Bytes : sig ... end
module Char : sig ... end
module Command : sig ... end
module Comparable : sig ... end
module Comparator : sig ... end
module Comparisons : sig ... end
module Container : sig ... end
module Container_intf : sig ... end
module Continue_or_stop : sig ... end
module Core_kernel_stable : sig ... end
module Core_stable : sig ... end
module Date : sig ... end
module Day_of_week : sig ... end
module Debug : sig ... end
module Deque : sig ... end
module Deriving_hash : sig ... end
module Digest : sig ... end
module Doubly_linked : sig ... end
module Either : sig ... end
module Ephemeron : sig ... end
module Equal : sig ... end
module Error : sig ... end
module Expect_test_config = Expect_test_config
module Fdeque : sig ... end
module Field : sig ... end
module Float : sig ... end
module Float_with_finite_only_serialization : sig ... end
module Floatable : sig ... end
module Fqueue : sig ... end
module Hash : sig ... end
module Hash_queue : sig ... end
module Hash_set : sig ... end
module Hashable : sig ... end
module Hashtbl : sig ... end
module Hashtbl_intf : sig ... end
module Heap_block : sig ... end
module Hexdump : sig ... end
module Hexdump_intf : sig ... end
module Host_and_port : sig ... end
module Identifiable : sig ... end
module In_channel : sig ... end
module Indexed_container : sig ... end
module Info : sig ... end
module Int32 : sig ... end
module Int63 : sig ... end
module Int64 : sig ... end
module Int_conversions : sig ... end
module Int_intf : sig ... end
module Int_math : sig ... end
module Intable : sig ... end
module Interfaces : sig ... end
module Invariant : sig ... end
module Lazy : sig ... end
module Linked_queue : sig ... end
module List : sig ... end
module Map_intf : sig ... end
module Maybe_bound : sig ... end
module Memo : sig ... end
module Monad : sig ... end
module Month : sig ... end
module Mutex = Core .Mutex
module Nativeint : sig ... end
module No_polymorphic_compare : sig ... end
module Nothing : sig ... end
module Only_in_test : sig ... end
module Option : sig ... end
module Option_array : sig ... end
module Optional_syntax : sig ... end
module Optional_syntax_intf : sig ... end
module Or_error : sig ... end
module Ordered_collection_common : sig ... end
module Ordering : sig ... end
module Out_channel : sig ... end
module Percent : sig ... end
module Perms : sig ... end
module Poly : sig ... end
module Polymorphic_compare = Poly
module Popcount = Base .Popcount
module Pretty_printer : sig ... end
module Printexc : sig ... end
module Printf : sig ... end
module Queue : sig ... end
module Quickcheck : sig ... end
module Quickcheck_intf : sig ... end
module Quickcheckable : sig ... end
module Random = Base .Random
module Result : sig ... end
module Robustly_comparable : sig ... end
module Sequence : sig ... end
module Set_intf : sig ... end
module Set_once : sig ... end
module Sexp_maybe : sig ... end
module Sexp : sig ... end
module Sexpable : sig ... end
module Sign : sig ... end
module Signal : sig ... end
module Sign_or_nan : sig ... end
module Source_code_position : sig ... end
module Splittable_random = Splittable_random
module Stable_comparable : sig ... end
module Stable_unit_test : sig ... end
module Stack : sig ... end
module Staged = Base .Staged
module String : sig ... end
module String_id : sig ... end
module Stringable : sig ... end
module Substring : sig ... end
module Substring_intf : sig ... end
module Thread = Core .Thread
module Time : sig ... end
module Time_ns : sig ... end
module Tuple : sig ... end
module Type_equal : sig ... end
module Uchar : sig ... end
module Union_find : sig ... end
module Unique_id : sig ... end
module Unit : sig ... end
module Unit_of_time : sig ... end
module Univ_map : sig ... end
module Validate = Validate
module Validated : sig ... end
module Variant : sig ... end
module Weak = Stdlib .Weak
module With_return : sig ... end
module Word_size : sig ... end
module type Unique_id = Core .Unique_id
module type T_bin = Core .T_bin
val raise_notrace : exn -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
val __POS__ : string * int * int * int
val __FUNCTION__ : string
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (|>) : 'a -> ('a -> 'b ) -> 'b
val (@@) : ('a -> 'b ) -> 'a -> 'b
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (asr) : int -> int -> int
val (~-.) : float -> float
val (~+.) : float -> float
val (+.) : float -> float -> float
val (-.) : float -> float -> float
val (*.) : float -> float -> float
val (/.) : float -> float -> float
val (**) : float -> float -> float
val sqrt : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : 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_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val epsilon_float : float
type fpclass = Caml .fpclass =
| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val string_of_bool : bool -> string
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string : string -> float
val fst : ('a * 'b ) -> 'a
val snd : ('a * 'b ) -> 'b
type in_channel = Caml .in_channel
type out_channel = Caml .out_channel
val stdin : Caml .in_channel
val stdout : Caml .out_channel
val stderr : Caml .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 : unit -> int
val read_float : unit -> float
type open_flag = Caml .open_flag =
| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock
val open_out : string -> Caml .out_channel
val open_out_bin : string -> Caml .out_channel
val open_out_gen : Caml .open_flag list -> int -> string -> Caml .out_channel
val flush : Caml .out_channel -> unit
val flush_all : unit -> unit
val output_char : Caml .out_channel -> char -> unit
val output_string : Caml .out_channel -> string -> unit
val output_bytes : Caml .out_channel -> bytes -> unit
val output : Caml .out_channel -> bytes -> int -> int -> unit
val output_substring : Caml .out_channel -> string -> int -> int -> unit
val output_byte : Caml .out_channel -> int -> unit
val output_binary_int : Caml .out_channel -> int -> unit
val output_value : Caml .out_channel -> 'a -> unit
val seek_out : Caml .out_channel -> int -> unit
val pos_out : Caml .out_channel -> int
val out_channel_length : Caml .out_channel -> int
val close_out : Caml .out_channel -> unit
val close_out_noerr : Caml .out_channel -> unit
val set_binary_mode_out : Caml .out_channel -> bool -> unit
val open_in : string -> Caml .in_channel
val open_in_bin : string -> Caml .in_channel
val open_in_gen : Caml .open_flag list -> int -> string -> Caml .in_channel
val seek_in : Caml .in_channel -> int -> unit
val pos_in : Caml .in_channel -> int
val in_channel_length : Caml .in_channel -> int
val close_in : Caml .in_channel -> unit
val close_in_noerr : Caml .in_channel -> unit
val set_binary_mode_in : Caml .in_channel -> bool -> unit
module LargeFile : sig ... end
type !'a ref = 'a Caml .ref = {
mutable contents : 'a ;
}
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type (!'a, !'b) result = ('a , 'b ) Caml .result =
| Ok of 'a
| Error of 'b
val (^^) :
('a , 'b , 'c , 'd , 'e , 'f ) format6 ->
('f , 'b , 'c , 'e , 'g , 'h ) format6 ->
('a , 'b , 'c , 'd , 'g , 'h ) format6
val at_exit : (unit -> unit) -> unit
val valid_float_lexem : string -> string
val do_at_exit : unit -> unit
val (>=) : Core__Int .t -> Core__Int .t -> bool
val (<=) : Core__Int .t -> Core__Int .t -> bool
val (>) : Core__Int .t -> Core__Int .t -> bool
val (<) : Core__Int .t -> Core__Int .t -> bool
val (<>) : Core__Int .t -> Core__Int .t -> bool
val min : Core__Int .t -> Core__Int .t -> Core__Int .t
val max : Core__Int .t -> Core__Int .t -> Core__Int .t
val quickcheck_generator_unit : Base .unit Base_quickcheck__ .Generator.t
val quickcheck_generator_bool : Base .bool Base_quickcheck__ .Generator.t
val quickcheck_generator_char : Base .char Base_quickcheck__ .Generator.t
val quickcheck_generator_string : Base .string Base_quickcheck__ .Generator.t
val quickcheck_generator_bytes : Base .bytes Base_quickcheck__ .Generator.t
val quickcheck_generator_int : Base .int Base_quickcheck__ .Generator.t
val quickcheck_generator_int32 : Base .int32 Base_quickcheck__ .Generator.t
val quickcheck_generator_int64 : Base .int64 Base_quickcheck__ .Generator.t
val quickcheck_generator_nativeint :
Base .nativeint Base_quickcheck__ .Generator.t
val quickcheck_generator_float : Base .float Base_quickcheck__ .Generator.t
val quickcheck_observer_unit : Base .unit Base_quickcheck__ .Observer.t
val quickcheck_observer_bool : Base .bool Base_quickcheck__ .Observer.t
val quickcheck_observer_char : Base .char Base_quickcheck__ .Observer.t
val quickcheck_observer_string : Base .string Base_quickcheck__ .Observer.t
val quickcheck_observer_bytes : Base .bytes Base_quickcheck__ .Observer.t
val quickcheck_observer_int : Base .int Base_quickcheck__ .Observer.t
val quickcheck_observer_int32 : Base .int32 Base_quickcheck__ .Observer.t
val quickcheck_observer_int64 : Base .int64 Base_quickcheck__ .Observer.t
val quickcheck_observer_nativeint : Base .nativeint Base_quickcheck__ .Observer.t
val quickcheck_observer_float : Base .float Base_quickcheck__ .Observer.t
val quickcheck_shrinker_unit : Base .unit Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_bool : Base .bool Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_char : Base .char Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_string : Base .string Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_bytes : Base .bytes Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_int : Base .int Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_int32 : Base .int32 Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_int64 : Base .int64 Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_nativeint : Base .nativeint Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_float : Base .float Base_quickcheck__ .Shrinker.t
val quickcheck_generator_option :
'a Base_quickcheck__ .Generator.t ->
'a Base .option Base_quickcheck__ .Generator.t
val quickcheck_generator_list :
'a Base_quickcheck__ .Generator.t ->
'a Base .list Base_quickcheck__ .Generator.t
val quickcheck_generator_array :
'a Base_quickcheck__ .Generator.t ->
'a Base .array Base_quickcheck__ .Generator.t
val quickcheck_generator_ref :
'a Base_quickcheck__ .Generator.t ->
'a Base .ref Base_quickcheck__ .Generator.t
val quickcheck_generator_lazy_t :
'a Base_quickcheck__ .Generator.t ->
'a Base .Lazy.t Base_quickcheck__ .Generator.t
val quickcheck_observer_option :
'a Base_quickcheck__ .Observer.t ->
'a Base .option Base_quickcheck__ .Observer.t
val quickcheck_observer_list :
'a Base_quickcheck__ .Observer.t ->
'a Base .list Base_quickcheck__ .Observer.t
val quickcheck_observer_array :
'a Base_quickcheck__ .Observer.t ->
'a Base .array Base_quickcheck__ .Observer.t
val quickcheck_observer_ref :
'a Base_quickcheck__ .Observer.t ->
'a Base .ref Base_quickcheck__ .Observer.t
val quickcheck_observer_lazy_t :
'a Base_quickcheck__ .Observer.t ->
'a Base .Lazy.t Base_quickcheck__ .Observer.t
val quickcheck_shrinker_option :
'a Base_quickcheck__ .Shrinker.t ->
'a Base .option Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_list :
'a Base_quickcheck__ .Shrinker.t ->
'a Base .list Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_array :
'a Base_quickcheck__ .Shrinker.t ->
'a Base .array Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_ref :
'a Base_quickcheck__ .Shrinker.t ->
'a Base .ref Base_quickcheck__ .Shrinker.t
val quickcheck_shrinker_lazy_t :
'a Base_quickcheck__ .Shrinker.t ->
'a Base .Lazy.t Base_quickcheck__ .Shrinker.t
val (|!) : 'a -> ('a -> 'b ) -> 'b
type (!'f, !'s) _either = ('f , 's ) Base__Either .t =
| First of 'f
| Second of 's
type bigstring = Sexplib .Conv.bigstring
val sexp_of_bigstring : bigstring -> Sexplib0 .Sexp.t
val bigstring_of_sexp : Sexplib0 .Sexp.t -> bigstring
type mat = Sexplib .Conv.mat
val sexp_of_mat : mat -> Sexplib0 .Sexp.t
val mat_of_sexp : Sexplib0 .Sexp.t -> mat
type vec = Sexplib .Conv.vec
val sexp_of_vec : vec -> Sexplib0 .Sexp.t
val vec_of_sexp : Sexplib0 .Sexp.t -> vec
val sexp_of_opaque : 'a -> Base .Sexp.t
val opaque_of_sexp : Base .Sexp.t -> 'a
val sexp_of_pair :
('a -> Base .Sexp.t) ->
('b -> Base .Sexp.t) ->
('a * 'b ) ->
Base .Sexp.t
val pair_of_sexp :
(Base .Sexp.t -> 'a ) ->
(Base .Sexp.t -> 'b ) ->
Base .Sexp.t ->
'a * 'b
exception Of_sexp_error of Core__Import .exn * Base .Sexp.t
val of_sexp_error : Core__Import .string -> Base .Sexp.t -> 'a
val of_sexp_error_exn : Core__Import .exn -> Base .Sexp.t -> 'a
module type Applicative = Core .Applicative
module type Binable = Core .Binable
module type Comparable = Core .Comparable
module type Comparable_binable = Core .Comparable_binable
module type Floatable = Core .Floatable
module type Hashable = Core .Hashable
module type Hashable_binable = Core .Hashable_binable
module type Identifiable = Core .Identifiable
module type Infix_comparators = Core .Infix_comparators
module type Intable = Core .Intable
module type Monad = Core .Monad
module type Quickcheckable = Core .Quickcheckable
module type Robustly_comparable = Core .Robustly_comparable
module type Sexpable = Core .Sexpable
module type Stable = Core .Stable
module type Stable_int63able = Core .Stable_int63able
module type Stable_without_comparator = Core .Stable_without_comparator
module type Stable1 = Core .Stable1
module type Stable2 = Core .Stable2
module type Stable3 = Core .Stable3
module type Stable4 = Core .Stable4
module type Stringable = Core .Stringable
module type Unit = Core .Unit
val (@) : 'a Base__List .t -> 'a Base__List .t -> 'a Base__List .t
type never_returns = Core__ .Nothing.t
type _ordering = Core__Ordering .t =
| Less
| Equal
| Greater
type read = Core__Perms .Read.t
val bin_shape_read : Bin_prot .Shape.t
val bin_size_read : read Bin_prot .Size.sizer
val bin_write_read : read Bin_prot .Write.writer
val bin_writer_read : read Bin_prot .Type_class.writer
val bin_read_read : read Bin_prot .Read.reader
val __bin_read_read__ : (Core__ .Import.int -> read ) Bin_prot .Read.reader
val bin_reader_read : read Bin_prot .Type_class.reader
val bin_read : read Bin_prot .Type_class.t
val compare_read : read -> read -> Core__ .Import.int
val hash_fold_read :
Ppx_hash_lib .Std.Hash.state ->
read ->
Ppx_hash_lib .Std.Hash.state
val hash_read : read -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_read : read -> Sexplib0 .Sexp.t
val read_of_sexp : Sexplib0 .Sexp.t -> read
type write = Core__Perms .Write.t
val compare_write : write -> write -> Core__ .Import.int
val hash_fold_write :
Ppx_hash_lib .Std.Hash.state ->
write ->
Ppx_hash_lib .Std.Hash.state
val hash_write : write -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_write : write -> Sexplib0 .Sexp.t
val write_of_sexp : Sexplib0 .Sexp.t -> write
type immutable = Core__Perms .Immutable.t
val bin_shape_immutable : Bin_prot .Shape.t
val bin_size_immutable : immutable Bin_prot .Size.sizer
val bin_write_immutable : immutable Bin_prot .Write.writer
val bin_writer_immutable : immutable Bin_prot .Type_class.writer
val bin_read_immutable : immutable Bin_prot .Read.reader
val __bin_read_immutable__ :
(Core__ .Import.int -> immutable ) Bin_prot .Read.reader
val bin_reader_immutable : immutable Bin_prot .Type_class.reader
val bin_immutable : immutable Bin_prot .Type_class.t
val hash_fold_immutable :
Ppx_hash_lib .Std.Hash.state ->
immutable ->
Ppx_hash_lib .Std.Hash.state
val hash_immutable : immutable -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_immutable : immutable -> Sexplib0 .Sexp.t
val immutable_of_sexp : Sexplib0 .Sexp.t -> immutable
type read_write = Core__Perms .Read_write.t
val bin_shape_read_write : Bin_prot .Shape.t
val bin_size_read_write : read_write Bin_prot .Size.sizer
val bin_write_read_write : read_write Bin_prot .Write.writer
val bin_writer_read_write : read_write Bin_prot .Type_class.writer
val bin_read_read_write : read_write Bin_prot .Read.reader
val __bin_read_read_write__ :
(Core__ .Import.int -> read_write ) Bin_prot .Read.reader
val bin_reader_read_write : read_write Bin_prot .Type_class.reader
val bin_read_write : read_write Bin_prot .Type_class.t
val hash_fold_read_write :
Ppx_hash_lib .Std.Hash.state ->
read_write ->
Ppx_hash_lib .Std.Hash.state
val hash_read_write : read_write -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_read_write : read_write -> Sexplib0 .Sexp.t
val read_write_of_sexp : Sexplib0 .Sexp.t -> read_write
type !'a perms = 'a Core__Perms .Upper_bound.t
val bin_shape_perms : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_perms : 'a Bin_prot .Size.sizer -> 'a perms Bin_prot .Size.sizer
val bin_write_perms :
'a Bin_prot .Write.writer ->
'a perms Bin_prot .Write.writer
val bin_writer_perms :
'a Bin_prot .Type_class.writer ->
'a perms Bin_prot .Type_class.writer
val bin_read_perms : 'a Bin_prot .Read.reader -> 'a perms Bin_prot .Read.reader
val __bin_read_perms__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a perms ) Bin_prot .Read.reader
val bin_reader_perms :
'a Bin_prot .Type_class.reader ->
'a perms Bin_prot .Type_class.reader
val bin_perms : 'a Bin_prot .Type_class.t -> 'a perms Bin_prot .Type_class.t
val compare_perms :
('a -> 'a -> Core__ .Import.int) ->
'a perms ->
'a perms ->
Core__ .Import.int
val hash_fold_perms :
(Ppx_hash_lib .Std.Hash.state -> 'a -> Ppx_hash_lib .Std.Hash.state) ->
Ppx_hash_lib .Std.Hash.state ->
'a perms ->
Ppx_hash_lib .Std.Hash.state
val sexp_of_perms : ('a -> Sexplib0 .Sexp.t) -> 'a perms -> Sexplib0 .Sexp.t
val perms_of_sexp : (Sexplib0 .Sexp.t -> 'a ) -> Sexplib0 .Sexp.t -> 'a perms
type (!'ok, !'err) _result = ('ok , 'err ) Core__Result .t =
| Ok of 'ok
| Error of 'err
val is_ok : ('a , 'b ) Core__Result .t -> bool
val is_error : ('a , 'b ) Core__Result .t -> bool
type !-'a return = private 'a Core__ .Import.With_return.return = {
return : 'b. 'a -> 'b ;
}
exception Bug of Core__ .Import.string
exception C_malloc_exn of Core__ .Import.int * Core__ .Import.int
exception Finally of Core__ .Import.Exn.t * Core__ .Import.Exn.t
val fst3 : ('a * 'b * 'c ) -> 'a
val snd3 : ('a * 'b * 'c ) -> 'b
val trd3 : ('a * 'b * 'c ) -> 'c
val uw : 'a Core__ .Import.option -> 'a
val (%) : Core__ .Int.t -> Core__ .Int.t -> Core__ .Int.t
val (/%) : Core__ .Int.t -> Core__ .Int.t -> Core__ .Int.t
val (//) : Core__ .Int.t -> Core__ .Int.t -> float
val (==>) : bool -> bool -> bool
val bprintf :
Base__ .Import0.Caml.Buffer.t ->
('a , Base__ .Import0.Caml.Buffer.t, unit) Stdlib .format ->
'a
val const : 'a -> 'b -> 'a
val eprintf :
('a , Stdlib .out_channel, Core__ .Import.unit) Core__ .Import.format ->
'a
val error :
?here :Base__ .Source_code_position0.t ->
?strict :unit ->
string ->
'a ->
('a -> Base__ .Sexp.t) ->
'b Core__ .Or_error.t
val error_s : Base__ .Sexp.t -> 'a Core__ .Or_error.t
val failwithp :
?strict :Core__ .Import.unit ->
Core__ .Source_code_position.t ->
Core__ .Import.string ->
'a ->
('a -> Core__ .Sexp.t) ->
'b
val failwiths :
?strict :Core__ .Import.unit ->
here :Stdlib .Lexing.position ->
Core__ .Import.string ->
'a ->
('a -> Base .Sexp.t) ->
'b
val force : 'a Base .Lazy.t -> 'a
val fprintf :
Stdlib .out_channel ->
('a , Stdlib .out_channel, Core__ .Import.unit) Core__ .Import.format ->
'a
val ifprintf : 'a -> ('b , 'a , 'c , unit) Stdlib .format4 -> 'b
val is_none : 'a option -> bool
val is_some : 'a option -> bool
val ksprintf : (string -> 'a ) -> ('b , unit, string, 'a ) Stdlib .format4 -> 'b
val ok_exn : 'a Core__ .Or_error.t -> 'a
val phys_equal : 'a -> 'a -> bool
val phys_same : 'a -> 'b -> bool
val print_s : ?mach :Base .unit -> Base .Sexp.t -> Base .unit
val eprint_s : ?mach :Base .unit -> Base .Sexp.t -> Base .unit
val printf :
('a , Stdlib .out_channel, Core__ .Import.unit) Core__ .Import.format ->
'a
val protect : f :(unit -> 'a ) -> finally :(unit -> unit) -> 'a
val protectx : f :('a -> 'b ) -> 'a -> finally :('a -> unit) -> 'b
val raise_s : Base__ .Sexp.t -> 'a
val round : ?dir :[ `Down | `Nearest | `Up | `Zero ] -> float -> float
val (**.) : Base__Float .t -> Base__Float .t -> Base__Float .t
val (%.) : Base__Float .t -> Base__Float .t -> Base__Float .t
val sprintf : ('a , unit, string) Stdlib .format -> 'a
val stage : 'a -> 'a Core__ .Import.Staged.t
val unstage : 'a Core__ .Import.Staged.t -> 'a
val with_return : ('a Core__ .Import.With_return.return -> 'a ) -> 'a
val with_return_option :
('a Core__ .Import.With_return.return -> unit) ->
'a option
module Typerep : sig ... end
val typerep_of_int63 : Base .Int63.t Typerep .t
type tuple0 = Typerep_lib__Std_internal .tuple0
val typerep_of_function : 'a Typerep .t -> 'b Typerep .t -> ('a -> 'b ) Typerep .t
val typerep_of_tuple0 : tuple0 Typerep .t
val typerep_of_tuple2 : 'a Typerep .t -> 'b Typerep .t -> ('a * 'b ) Typerep .t
val typerep_of_tuple3 :
'a Typerep .t ->
'b Typerep .t ->
'c Typerep .t ->
('a * 'b * 'c ) Typerep .t
val typerep_of_tuple4 :
'a Typerep .t ->
'b Typerep .t ->
'c Typerep .t ->
'd Typerep .t ->
('a * 'b * 'c * 'd ) Typerep .t
val typerep_of_tuple5 :
'a Typerep .t ->
'b Typerep .t ->
'c Typerep .t ->
'd Typerep .t ->
'e Typerep .t ->
('a * 'b * 'c * 'd * 'e ) Typerep .t
val typename_of_int63 : Base .Int63.t Typerep_lib .Typename.t
val typename_of_function :
'a Typerep_lib .Typename.t ->
'b Typerep_lib .Typename.t ->
('a -> 'b ) Typerep_lib .Typename.t
val typename_of_tuple0 : tuple0 Typerep_lib .Typename.t
val typename_of_tuple2 :
'a Typerep_lib .Typename.t ->
'b Typerep_lib .Typename.t ->
('a * 'b ) Typerep_lib .Typename.t
val typename_of_tuple3 :
'a Typerep_lib .Typename.t ->
'b Typerep_lib .Typename.t ->
'c Typerep_lib .Typename.t ->
('a * 'b * 'c ) Typerep_lib .Typename.t
val typename_of_tuple4 :
'a Typerep_lib .Typename.t ->
'b Typerep_lib .Typename.t ->
'c Typerep_lib .Typename.t ->
'd Typerep_lib .Typename.t ->
('a * 'b * 'c * 'd ) Typerep_lib .Typename.t
val typename_of_tuple5 :
'a Typerep_lib .Typename.t ->
'b Typerep_lib .Typename.t ->
'c Typerep_lib .Typename.t ->
'd Typerep_lib .Typename.t ->
'e Typerep_lib .Typename.t ->
('a * 'b * 'c * 'd * 'e ) Typerep_lib .Typename.t
val bin_shape_array : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_array :
'a Bin_prot .Size.sizer ->
'a Core__ .Import.array Bin_prot .Size.sizer
val bin_write_array :
'a Bin_prot .Write.writer ->
'a Core__ .Import.array Bin_prot .Write.writer
val bin_writer_array :
'a Bin_prot .Type_class.writer ->
'a Core__ .Import.array Bin_prot .Type_class.writer
val bin_read_array :
'a Bin_prot .Read.reader ->
'a Core__ .Import.array Bin_prot .Read.reader
val __bin_read_array__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a Core__ .Import.array ) Bin_prot .Read.reader
val bin_reader_array :
'a Bin_prot .Type_class.reader ->
'a Core__ .Import.array Bin_prot .Type_class.reader
val bin_array :
'a Bin_prot .Type_class.t ->
'a Core__ .Import.array Bin_prot .Type_class.t
val compare_array :
('a -> 'a -> Core__ .Import.int) ->
'a Core__ .Import.array ->
'a Core__ .Import.array ->
Core__ .Import.int
val equal_array :
('a -> 'a -> Core__ .Import.bool) ->
'a Core__ .Import.array ->
'a Core__ .Import.array ->
Core__ .Import.bool
val sexp_of_array :
('a -> Sexplib0 .Sexp.t) ->
'a Core__ .Import.array ->
Sexplib0 .Sexp.t
val array_of_sexp :
(Sexplib0 .Sexp.t -> 'a ) ->
Sexplib0 .Sexp.t ->
'a Core__ .Import.array
val array_sexp_grammar :
'a Sexplib0 .Sexp_grammar.t ->
'a Core__ .Import.array Sexplib0 .Sexp_grammar.t
val typerep_of_array :
'a Typerep_lib .Std.Typerep.t ->
'a Core__ .Import.array Typerep_lib .Std.Typerep.t
val typename_of_array :
'a Typerep_lib .Std.Typename.t ->
'a Core__ .Import.array Typerep_lib .Std.Typename.t
val bin_shape_bool : Bin_prot .Shape.t
val bin_size_bool : Core__ .Import.bool Bin_prot .Size.sizer
val bin_write_bool : Core__ .Import.bool Bin_prot .Write.writer
val bin_writer_bool : Core__ .Import.bool Bin_prot .Type_class.writer
val bin_read_bool : Core__ .Import.bool Bin_prot .Read.reader
val __bin_read_bool__ :
(Core__ .Import.int -> Core__ .Import.bool) Bin_prot .Read.reader
val bin_reader_bool : Core__ .Import.bool Bin_prot .Type_class.reader
val bin_bool : Core__ .Import.bool Bin_prot .Type_class.t
val compare_bool :
Core__ .Import.bool ->
Core__ .Import.bool ->
Core__ .Import.int
val equal_bool : Core__ .Import.bool -> Core__ .Import.bool -> Core__ .Import.bool
val hash_fold_bool :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.bool ->
Ppx_hash_lib .Std.Hash.state
val hash_bool : Core__ .Import.bool -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_bool : Core__ .Import.bool -> Sexplib0 .Sexp.t
val bool_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.bool
val bool_sexp_grammar : Core__ .Import.bool Sexplib0 .Sexp_grammar.t
val typerep_of_bool : Core__ .Import.bool Typerep_lib .Std.Typerep.t
val typename_of_bool : Core__ .Import.bool Typerep_lib .Std.Typename.t
val bin_shape_char : Bin_prot .Shape.t
val bin_size_char : Core__ .Import.char Bin_prot .Size.sizer
val bin_write_char : Core__ .Import.char Bin_prot .Write.writer
val bin_writer_char : Core__ .Import.char Bin_prot .Type_class.writer
val bin_read_char : Core__ .Import.char Bin_prot .Read.reader
val __bin_read_char__ :
(Core__ .Import.int -> Core__ .Import.char) Bin_prot .Read.reader
val bin_reader_char : Core__ .Import.char Bin_prot .Type_class.reader
val bin_char : Core__ .Import.char Bin_prot .Type_class.t
val compare_char :
Core__ .Import.char ->
Core__ .Import.char ->
Core__ .Import.int
val equal_char : Core__ .Import.char -> Core__ .Import.char -> Core__ .Import.bool
val hash_fold_char :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.char ->
Ppx_hash_lib .Std.Hash.state
val hash_char : Core__ .Import.char -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_char : Core__ .Import.char -> Sexplib0 .Sexp.t
val char_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.char
val char_sexp_grammar : Core__ .Import.char Sexplib0 .Sexp_grammar.t
val typerep_of_char : Core__ .Import.char Typerep_lib .Std.Typerep.t
val typename_of_char : Core__ .Import.char Typerep_lib .Std.Typename.t
val bin_shape_float : Bin_prot .Shape.t
val bin_size_float : Core__ .Import.float Bin_prot .Size.sizer
val bin_write_float : Core__ .Import.float Bin_prot .Write.writer
val bin_writer_float : Core__ .Import.float Bin_prot .Type_class.writer
val bin_read_float : Core__ .Import.float Bin_prot .Read.reader
val __bin_read_float__ :
(Core__ .Import.int -> Core__ .Import.float) Bin_prot .Read.reader
val bin_reader_float : Core__ .Import.float Bin_prot .Type_class.reader
val bin_float : Core__ .Import.float Bin_prot .Type_class.t
val compare_float :
Core__ .Import.float ->
Core__ .Import.float ->
Core__ .Import.int
val equal_float :
Core__ .Import.float ->
Core__ .Import.float ->
Core__ .Import.bool
val hash_fold_float :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.float ->
Ppx_hash_lib .Std.Hash.state
val hash_float : Core__ .Import.float -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_float : Core__ .Import.float -> Sexplib0 .Sexp.t
val float_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.float
val float_sexp_grammar : Core__ .Import.float Sexplib0 .Sexp_grammar.t
val typerep_of_float : Core__ .Import.float Typerep_lib .Std.Typerep.t
val typename_of_float : Core__ .Import.float Typerep_lib .Std.Typename.t
val bin_shape_int : Bin_prot .Shape.t
val bin_size_int : Core__ .Import.int Bin_prot .Size.sizer
val bin_write_int : Core__ .Import.int Bin_prot .Write.writer
val bin_writer_int : Core__ .Import.int Bin_prot .Type_class.writer
val bin_read_int : Core__ .Import.int Bin_prot .Read.reader
val __bin_read_int__ :
(Core__ .Import.int -> Core__ .Import.int) Bin_prot .Read.reader
val bin_reader_int : Core__ .Import.int Bin_prot .Type_class.reader
val bin_int : Core__ .Import.int Bin_prot .Type_class.t
val compare_int : Core__ .Import.int -> Core__ .Import.int -> Core__ .Import.int
val equal_int : Core__ .Import.int -> Core__ .Import.int -> Core__ .Import.bool
val hash_fold_int :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.int ->
Ppx_hash_lib .Std.Hash.state
val hash_int : Core__ .Import.int -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_int : Core__ .Import.int -> Sexplib0 .Sexp.t
val int_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.int
val int_sexp_grammar : Core__ .Import.int Sexplib0 .Sexp_grammar.t
val typerep_of_int : Core__ .Import.int Typerep_lib .Std.Typerep.t
val typename_of_int : Core__ .Import.int Typerep_lib .Std.Typename.t
val bin_shape_int32 : Bin_prot .Shape.t
val bin_size_int32 : Core__ .Import.int32 Bin_prot .Size.sizer
val bin_write_int32 : Core__ .Import.int32 Bin_prot .Write.writer
val bin_writer_int32 : Core__ .Import.int32 Bin_prot .Type_class.writer
val bin_read_int32 : Core__ .Import.int32 Bin_prot .Read.reader
val __bin_read_int32__ :
(Core__ .Import.int -> Core__ .Import.int32) Bin_prot .Read.reader
val bin_reader_int32 : Core__ .Import.int32 Bin_prot .Type_class.reader
val bin_int32 : Core__ .Import.int32 Bin_prot .Type_class.t
val compare_int32 :
Core__ .Import.int32 ->
Core__ .Import.int32 ->
Core__ .Import.int
val equal_int32 :
Core__ .Import.int32 ->
Core__ .Import.int32 ->
Core__ .Import.bool
val hash_fold_int32 :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.int32 ->
Ppx_hash_lib .Std.Hash.state
val hash_int32 : Core__ .Import.int32 -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_int32 : Core__ .Import.int32 -> Sexplib0 .Sexp.t
val int32_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.int32
val int32_sexp_grammar : Core__ .Import.int32 Sexplib0 .Sexp_grammar.t
val typerep_of_int32 : Core__ .Import.int32 Typerep_lib .Std.Typerep.t
val typename_of_int32 : Core__ .Import.int32 Typerep_lib .Std.Typename.t
val bin_shape_int64 : Bin_prot .Shape.t
val bin_size_int64 : Core__ .Import.int64 Bin_prot .Size.sizer
val bin_write_int64 : Core__ .Import.int64 Bin_prot .Write.writer
val bin_writer_int64 : Core__ .Import.int64 Bin_prot .Type_class.writer
val bin_read_int64 : Core__ .Import.int64 Bin_prot .Read.reader
val __bin_read_int64__ :
(Core__ .Import.int -> Core__ .Import.int64) Bin_prot .Read.reader
val bin_reader_int64 : Core__ .Import.int64 Bin_prot .Type_class.reader
val bin_int64 : Core__ .Import.int64 Bin_prot .Type_class.t
val compare_int64 :
Core__ .Import.int64 ->
Core__ .Import.int64 ->
Core__ .Import.int
val equal_int64 :
Core__ .Import.int64 ->
Core__ .Import.int64 ->
Core__ .Import.bool
val hash_fold_int64 :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.int64 ->
Ppx_hash_lib .Std.Hash.state
val hash_int64 : Core__ .Import.int64 -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_int64 : Core__ .Import.int64 -> Sexplib0 .Sexp.t
val int64_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.int64
val int64_sexp_grammar : Core__ .Import.int64 Sexplib0 .Sexp_grammar.t
val typerep_of_int64 : Core__ .Import.int64 Typerep_lib .Std.Typerep.t
val typename_of_int64 : Core__ .Import.int64 Typerep_lib .Std.Typename.t
val bin_shape_lazy_t : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_lazy_t : 'a Bin_prot .Size.sizer -> 'a lazy_t Bin_prot .Size.sizer
val bin_write_lazy_t :
'a Bin_prot .Write.writer ->
'a lazy_t Bin_prot .Write.writer
val bin_writer_lazy_t :
'a Bin_prot .Type_class.writer ->
'a lazy_t Bin_prot .Type_class.writer
val bin_read_lazy_t : 'a Bin_prot .Read.reader -> 'a lazy_t Bin_prot .Read.reader
val __bin_read_lazy_t__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a lazy_t ) Bin_prot .Read.reader
val bin_reader_lazy_t :
'a Bin_prot .Type_class.reader ->
'a lazy_t Bin_prot .Type_class.reader
val bin_lazy_t : 'a Bin_prot .Type_class.t -> 'a lazy_t Bin_prot .Type_class.t
val compare_lazy_t :
('a -> 'a -> Core__ .Import.int) ->
'a lazy_t ->
'a lazy_t ->
Core__ .Import.int
val hash_fold_lazy_t :
(Ppx_hash_lib .Std.Hash.state -> 'a -> Ppx_hash_lib .Std.Hash.state) ->
Ppx_hash_lib .Std.Hash.state ->
'a lazy_t ->
Ppx_hash_lib .Std.Hash.state
val sexp_of_lazy_t : ('a -> Sexplib0 .Sexp.t) -> 'a lazy_t -> Sexplib0 .Sexp.t
val lazy_t_of_sexp : (Sexplib0 .Sexp.t -> 'a ) -> Sexplib0 .Sexp.t -> 'a lazy_t
val lazy_t_sexp_grammar :
'a Sexplib0 .Sexp_grammar.t ->
'a lazy_t Sexplib0 .Sexp_grammar.t
val typerep_of_lazy_t :
'a Typerep_lib .Std.Typerep.t ->
'a lazy_t Typerep_lib .Std.Typerep.t
val typename_of_lazy_t :
'a Typerep_lib .Std.Typename.t ->
'a lazy_t Typerep_lib .Std.Typename.t
val bin_shape_list : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_list :
'a Bin_prot .Size.sizer ->
'a Core__ .Import.list Bin_prot .Size.sizer
val bin_write_list :
'a Bin_prot .Write.writer ->
'a Core__ .Import.list Bin_prot .Write.writer
val bin_writer_list :
'a Bin_prot .Type_class.writer ->
'a Core__ .Import.list Bin_prot .Type_class.writer
val bin_read_list :
'a Bin_prot .Read.reader ->
'a Core__ .Import.list Bin_prot .Read.reader
val __bin_read_list__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a Core__ .Import.list ) Bin_prot .Read.reader
val bin_reader_list :
'a Bin_prot .Type_class.reader ->
'a Core__ .Import.list Bin_prot .Type_class.reader
val bin_list :
'a Bin_prot .Type_class.t ->
'a Core__ .Import.list Bin_prot .Type_class.t
val compare_list :
('a -> 'a -> Core__ .Import.int) ->
'a Core__ .Import.list ->
'a Core__ .Import.list ->
Core__ .Import.int
val equal_list :
('a -> 'a -> Core__ .Import.bool) ->
'a Core__ .Import.list ->
'a Core__ .Import.list ->
Core__ .Import.bool
val hash_fold_list :
(Ppx_hash_lib .Std.Hash.state -> 'a -> Ppx_hash_lib .Std.Hash.state) ->
Ppx_hash_lib .Std.Hash.state ->
'a Core__ .Import.list ->
Ppx_hash_lib .Std.Hash.state
val sexp_of_list :
('a -> Sexplib0 .Sexp.t) ->
'a Core__ .Import.list ->
Sexplib0 .Sexp.t
val list_of_sexp :
(Sexplib0 .Sexp.t -> 'a ) ->
Sexplib0 .Sexp.t ->
'a Core__ .Import.list
val list_sexp_grammar :
'a Sexplib0 .Sexp_grammar.t ->
'a Core__ .Import.list Sexplib0 .Sexp_grammar.t
val typerep_of_list :
'a Typerep_lib .Std.Typerep.t ->
'a Core__ .Import.list Typerep_lib .Std.Typerep.t
val typename_of_list :
'a Typerep_lib .Std.Typename.t ->
'a Core__ .Import.list Typerep_lib .Std.Typename.t
val bin_shape_nativeint : Bin_prot .Shape.t
val bin_size_nativeint : Core__ .Import.nativeint Bin_prot .Size.sizer
val bin_write_nativeint : Core__ .Import.nativeint Bin_prot .Write.writer
val bin_writer_nativeint : Core__ .Import.nativeint Bin_prot .Type_class.writer
val bin_read_nativeint : Core__ .Import.nativeint Bin_prot .Read.reader
val __bin_read_nativeint__ :
(Core__ .Import.int -> Core__ .Import.nativeint) Bin_prot .Read.reader
val bin_reader_nativeint : Core__ .Import.nativeint Bin_prot .Type_class.reader
val bin_nativeint : Core__ .Import.nativeint Bin_prot .Type_class.t
val compare_nativeint :
Core__ .Import.nativeint ->
Core__ .Import.nativeint ->
Core__ .Import.int
val equal_nativeint :
Core__ .Import.nativeint ->
Core__ .Import.nativeint ->
Core__ .Import.bool
val hash_fold_nativeint :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.nativeint ->
Ppx_hash_lib .Std.Hash.state
val hash_nativeint :
Core__ .Import.nativeint ->
Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_nativeint : Core__ .Import.nativeint -> Sexplib0 .Sexp.t
val nativeint_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.nativeint
val nativeint_sexp_grammar : Core__ .Import.nativeint Sexplib0 .Sexp_grammar.t
val typerep_of_nativeint : Core__ .Import.nativeint Typerep_lib .Std.Typerep.t
val typename_of_nativeint : Core__ .Import.nativeint Typerep_lib .Std.Typename.t
val bin_shape_option : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_option :
'a Bin_prot .Size.sizer ->
'a Core__ .Import.option Bin_prot .Size.sizer
val bin_write_option :
'a Bin_prot .Write.writer ->
'a Core__ .Import.option Bin_prot .Write.writer
val bin_writer_option :
'a Bin_prot .Type_class.writer ->
'a Core__ .Import.option Bin_prot .Type_class.writer
val bin_read_option :
'a Bin_prot .Read.reader ->
'a Core__ .Import.option Bin_prot .Read.reader
val __bin_read_option__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a Core__ .Import.option ) Bin_prot .Read.reader
val bin_reader_option :
'a Bin_prot .Type_class.reader ->
'a Core__ .Import.option Bin_prot .Type_class.reader
val bin_option :
'a Bin_prot .Type_class.t ->
'a Core__ .Import.option Bin_prot .Type_class.t
val compare_option :
('a -> 'a -> Core__ .Import.int) ->
'a Core__ .Import.option ->
'a Core__ .Import.option ->
Core__ .Import.int
val equal_option :
('a -> 'a -> Core__ .Import.bool) ->
'a Core__ .Import.option ->
'a Core__ .Import.option ->
Core__ .Import.bool
val hash_fold_option :
(Ppx_hash_lib .Std.Hash.state -> 'a -> Ppx_hash_lib .Std.Hash.state) ->
Ppx_hash_lib .Std.Hash.state ->
'a Core__ .Import.option ->
Ppx_hash_lib .Std.Hash.state
val sexp_of_option :
('a -> Sexplib0 .Sexp.t) ->
'a Core__ .Import.option ->
Sexplib0 .Sexp.t
val option_of_sexp :
(Sexplib0 .Sexp.t -> 'a ) ->
Sexplib0 .Sexp.t ->
'a Core__ .Import.option
val option_sexp_grammar :
'a Sexplib0 .Sexp_grammar.t ->
'a Core__ .Import.option Sexplib0 .Sexp_grammar.t
val typerep_of_option :
'a Typerep_lib .Std.Typerep.t ->
'a Core__ .Import.option Typerep_lib .Std.Typerep.t
val typename_of_option :
'a Typerep_lib .Std.Typename.t ->
'a Core__ .Import.option Typerep_lib .Std.Typename.t
val bin_shape_string : Bin_prot .Shape.t
val bin_size_string : Core__ .Import.string Bin_prot .Size.sizer
val bin_write_string : Core__ .Import.string Bin_prot .Write.writer
val bin_writer_string : Core__ .Import.string Bin_prot .Type_class.writer
val bin_read_string : Core__ .Import.string Bin_prot .Read.reader
val __bin_read_string__ :
(Core__ .Import.int -> Core__ .Import.string) Bin_prot .Read.reader
val bin_reader_string : Core__ .Import.string Bin_prot .Type_class.reader
val bin_string : Core__ .Import.string Bin_prot .Type_class.t
val compare_string :
Core__ .Import.string ->
Core__ .Import.string ->
Core__ .Import.int
val equal_string :
Core__ .Import.string ->
Core__ .Import.string ->
Core__ .Import.bool
val hash_fold_string :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.string ->
Ppx_hash_lib .Std.Hash.state
val hash_string : Core__ .Import.string -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_string : Core__ .Import.string -> Sexplib0 .Sexp.t
val string_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.string
val string_sexp_grammar : Core__ .Import.string Sexplib0 .Sexp_grammar.t
val typerep_of_string : Core__ .Import.string Typerep_lib .Std.Typerep.t
val typename_of_string : Core__ .Import.string Typerep_lib .Std.Typename.t
val bin_shape_bytes : Bin_prot .Shape.t
val bin_size_bytes : Core__ .Import.bytes Bin_prot .Size.sizer
val bin_write_bytes : Core__ .Import.bytes Bin_prot .Write.writer
val bin_writer_bytes : Core__ .Import.bytes Bin_prot .Type_class.writer
val bin_read_bytes : Core__ .Import.bytes Bin_prot .Read.reader
val __bin_read_bytes__ :
(Core__ .Import.int -> Core__ .Import.bytes) Bin_prot .Read.reader
val bin_reader_bytes : Core__ .Import.bytes Bin_prot .Type_class.reader
val bin_bytes : Core__ .Import.bytes Bin_prot .Type_class.t
val compare_bytes :
Core__ .Import.bytes ->
Core__ .Import.bytes ->
Core__ .Import.int
val equal_bytes :
Core__ .Import.bytes ->
Core__ .Import.bytes ->
Core__ .Import.bool
val sexp_of_bytes : Core__ .Import.bytes -> Sexplib0 .Sexp.t
val bytes_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.bytes
val bytes_sexp_grammar : Core__ .Import.bytes Sexplib0 .Sexp_grammar.t
val typerep_of_bytes : Core__ .Import.bytes Typerep_lib .Std.Typerep.t
val typename_of_bytes : Core__ .Import.bytes Typerep_lib .Std.Typename.t
val bin_shape_ref : Bin_prot .Shape.t -> Bin_prot .Shape.t
val bin_size_ref : 'a Bin_prot .Size.sizer -> 'a ref Bin_prot .Size.sizer
val bin_write_ref : 'a Bin_prot .Write.writer -> 'a ref Bin_prot .Write.writer
val bin_writer_ref :
'a Bin_prot .Type_class.writer ->
'a ref Bin_prot .Type_class.writer
val bin_read_ref : 'a Bin_prot .Read.reader -> 'a ref Bin_prot .Read.reader
val __bin_read_ref__ :
'a Bin_prot .Read.reader ->
(Core__ .Import.int -> 'a ref ) Bin_prot .Read.reader
val bin_reader_ref :
'a Bin_prot .Type_class.reader ->
'a ref Bin_prot .Type_class.reader
val bin_ref : 'a Bin_prot .Type_class.t -> 'a ref Bin_prot .Type_class.t
val compare_ref :
('a -> 'a -> Core__ .Import.int) ->
'a ref ->
'a ref ->
Core__ .Import.int
val equal_ref :
('a -> 'a -> Core__ .Import.bool) ->
'a ref ->
'a ref ->
Core__ .Import.bool
val sexp_of_ref : ('a -> Sexplib0 .Sexp.t) -> 'a ref -> Sexplib0 .Sexp.t
val ref_of_sexp : (Sexplib0 .Sexp.t -> 'a ) -> Sexplib0 .Sexp.t -> 'a ref
val ref_sexp_grammar :
'a Sexplib0 .Sexp_grammar.t ->
'a ref Sexplib0 .Sexp_grammar.t
val typerep_of_ref :
'a Typerep_lib .Std.Typerep.t ->
'a ref Typerep_lib .Std.Typerep.t
val typename_of_ref :
'a Typerep_lib .Std.Typename.t ->
'a ref Typerep_lib .Std.Typename.t
val bin_shape_unit : Bin_prot .Shape.t
val bin_size_unit : Core__ .Import.unit Bin_prot .Size.sizer
val bin_write_unit : Core__ .Import.unit Bin_prot .Write.writer
val bin_writer_unit : Core__ .Import.unit Bin_prot .Type_class.writer
val bin_read_unit : Core__ .Import.unit Bin_prot .Read.reader
val __bin_read_unit__ :
(Core__ .Import.int -> Core__ .Import.unit) Bin_prot .Read.reader
val bin_reader_unit : Core__ .Import.unit Bin_prot .Type_class.reader
val bin_unit : Core__ .Import.unit Bin_prot .Type_class.t
val compare_unit :
Core__ .Import.unit ->
Core__ .Import.unit ->
Core__ .Import.int
val equal_unit : Core__ .Import.unit -> Core__ .Import.unit -> Core__ .Import.bool
val hash_fold_unit :
Ppx_hash_lib .Std.Hash.state ->
Core__ .Import.unit ->
Ppx_hash_lib .Std.Hash.state
val hash_unit : Core__ .Import.unit -> Ppx_hash_lib .Std.Hash.hash_value
val sexp_of_unit : Core__ .Import.unit -> Sexplib0 .Sexp.t
val unit_of_sexp : Sexplib0 .Sexp.t -> Core__ .Import.unit
val unit_sexp_grammar : Core__ .Import.unit Sexplib0 .Sexp_grammar.t
val typerep_of_unit : Core__ .Import.unit Typerep_lib .Std.Typerep.t
val typename_of_unit : Core__ .Import.unit Typerep_lib .Std.Typename.t
type float_array = Core__ .Import.float Core__ .Import.array
val bin_shape_float_array : Bin_prot .Shape.t
val bin_size_float_array : float_array Bin_prot .Size.sizer
val bin_write_float_array : float_array Bin_prot .Write.writer
val bin_writer_float_array : float_array Bin_prot .Type_class.writer
val bin_read_float_array : float_array Bin_prot .Read.reader
val __bin_read_float_array__ :
(Core__ .Import.int -> float_array ) Bin_prot .Read.reader
val bin_reader_float_array : float_array Bin_prot .Type_class.reader
val bin_float_array : float_array Bin_prot .Type_class.t
val sexp_of_float_array : float_array -> Sexplib0 .Sexp.t
val float_array_of_sexp : Sexplib0 .Sexp.t -> float_array
val float_array_sexp_grammar : float_array Sexplib0 .Sexp_grammar.t
val typerep_of_float_array : float_array Typerep_lib .Std.Typerep.t
val typename_of_float_array : float_array Typerep_lib .Std.Typename.t
val sexp_of_exn : Core__ .Import.Exn.t -> Sexplib0 .Sexp.t
exception Not_found_s of Sexplib0 .Sexp.t
type !'a _maybe_bound = 'a Maybe_bound .t =
| Incl of 'a
| Excl of 'a
| Unbounded
val am_running_inline_test : bool
val am_running_test : bool
val does_raise : (unit -> 'a ) -> bool
val sec : Core__ .Import.float -> Core__ .Time_float.Span.t
val (^/) : Core__ .Import.string -> Core__ .Import.string -> Core__ .Import.string
module Core_private = Core .Core_private
val compare : No_polymorphic_compare .compare
val equal : No_polymorphic_compare .compare
val (=) : No_polymorphic_compare .compare
val failwith : 'a -> [ `use_Logging_die_instead ]
val failwithf : 'a -> [ `use_Logging_die_instead ]
val invalid_arg : 'a -> [ `use_Logging_die_instead ]
val invalid_argf : 'a -> [ `use_Logging_die_instead ]
val exit : [> `In_general_prefer_using_Logging_exit_over_Pervasives_exit ]
module ANSITerminal : module type of ANSITerminal