Import (sexp_pretty.Sexp

include module type of sig ... end with module Sexp := Base.Sexp

module Arg = Base.Arg

module ArrayLabels = Base.ArrayLabels

module Bytes = Base.Bytes

module BytesLabels = Base.BytesLabels

module Callback = Base.Callback

module Complex = Base.Complex

module Digest = Base.Digest

module Ephemeron = Base.Ephemeron

module Filename = Base.Filename

module Format = Base.Format

module Gc = Base.Gc

module Genlex = Base.Genlex

module ListLabels = Base.ListLabels

module Marshal = Base.Marshal

module MoreLabels = Base.MoreLabels

module Obj = Base.Obj

module Oo = Base.Oo

module Parsing = Base.Parsing

module Pervasives = Base.Pervasives

module Printexc = Base.Printexc

module Queue = Base.Queue

module Scanf = Base.Scanf

module Sort = Base.Sort

module Spacetime = Base.Spacetime

module Stack = Base.Stack

module StdLabels = Base.StdLabels

module Stream = Base.Stream

module StringLabels = Base.StringLabels

module Weak = Base.Weak

external raise_notrace : exn ‑> 'a =

exception Exit

external (==) : 'a ‑> 'a ‑> bool =

external (!=) : 'a ‑> 'a ‑> bool =

external (&) : bool ‑> bool ‑> bool =

external or : bool ‑> bool ‑> bool =

external __LOC__ : string =

external __FILE__ : string =

external __LINE__ : int =

external __MODULE__ : string =

external __POS__ : string * int * int * int =

external __LOC_OF__ : 'a ‑> string * 'a =

external __LINE_OF__ : 'a ‑> int * 'a =

external __POS_OF__ : 'a ‑> (string * int * int * int) * 'a =

external (@@) : ('a ‑> 'b) ‑> 'a ‑> 'b =

external (~+) : int ‑> int =

external succ : int ‑> int =

external pred : int ‑> int =

external (mod) : int ‑> int ‑> int =

val max_int : int

val min_int : int

external (~-.) : float ‑> float =

external (~+.) : float ‑> float =

external (+.) : float ‑> float ‑> float =

external (-.) : float ‑> float ‑> float =

external (*.) : float ‑> float ‑> float =

external (/.) : float ‑> float ‑> float =

external (**) : float ‑> float ‑> float =

external sqrt : float ‑> float =

external exp : float ‑> float =

external log : float ‑> float =

external log10 : float ‑> float =

external expm1 : float ‑> float =

external log1p : float ‑> float =

external cos : float ‑> float =

external sin : float ‑> float =

external tan : float ‑> float =

external acos : float ‑> float =

external asin : float ‑> float =

external atan : float ‑> float =

external atan2 : float ‑> float ‑> float =

external hypot : float ‑> float ‑> float =

external cosh : float ‑> float =

external sinh : float ‑> float =

external tanh : float ‑> float =

external ceil : float ‑> float =

external floor : float ‑> float =

external abs_float : float ‑> float =

external copysign : float ‑> float ‑> float =

external mod_float : float ‑> float ‑> float =

external frexp : float ‑> float * int =

external ldexp : float ‑> int ‑> float =

external modf : float ‑> float * float =

external float : int ‑> float =

external float_of_int : int ‑> float =

external truncate : float ‑> int =

external 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 fpclass = Pervasives.fpclass =

| FP_normal

| FP_subnormal

| FP_zero

| FP_infinite

| FP_nan

external classify_float : float ‑> fpclass =

external 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

external int_of_string : string ‑> int =

val string_of_float : float ‑> string

external float_of_string : string ‑> float =

type in_channel = Pervasives.in_channel

type out_channel = Pervasives.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 : unit ‑> int

val read_float : unit ‑> float

type open_flag = Pervasives.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 = Base.LargeFile

external incr : int Pervasives.ref ‑> unit =

external decr : int Pervasives.ref ‑> unit =

type ('a, 'b) result = ('a, 'b) Pervasives.result =

| Ok of 'a

| Error of 'b

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

external format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 ‑> ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 =

val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.format6 ‑> ('f, 'b, 'c, 'e, 'g, 'h) Pervasives.format6 ‑> ('a, 'b, 'c, 'd, 'g, 'h) Pervasives.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 Applicative = Base.Applicative

module Applicative_intf = Base.Applicative_intf

module Array = Base.Array

module Avltree = Base.Avltree

module Backtrace = Base.Backtrace

module Binary_search = Base.Binary_search

module Binary_searchable = Base.Binary_searchable

module Binary_searchable_intf = Base.Binary_searchable_intf

module Blit = Base.Blit

module Blit_intf = Base.Blit_intf

module Bool = Base.Bool

module Buffer = Base.Buffer

module Char = Base.Char

module Commutative_group = Base.Commutative_group

module Comparable = Base.Comparable

module Comparable_intf = Base.Comparable_intf

module Comparator = Base.Comparator

module Container = Base.Container

module Container_intf = Base.Container_intf

module Either = Base.Either

module Either_intf = Base.Either_intf

module Equal = Base.Equal

module Error = Base.Error

module Exn = Base.Exn

module Field = Base.Field

module Float = Base.Float

module Floatable = Base.Floatable

module Fn = Base.Fn

module Hash = Base.Hash

module Hash_intf = Base.Hash_intf

module Hash_set = Base.Hash_set

module Hash_set_intf = Base.Hash_set_intf

module Hasher = Base.Hasher

module Hashtbl = Base.Hashtbl

module Hashtbl_intf = Base.Hashtbl_intf

module Heap_block = Base.Heap_block

module Identifiable = Base.Identifiable

module Indexed_container = Base.Indexed_container

module Info = Base.Info

module Info_intf = Base.Info_intf

module Int = Base.Int

module Int32 = Base.Int32

module Int63 = Base.Int63

module Int64 = Base.Int64

module Int_intf = Base.Int_intf

module Intable = Base.Intable

module Invariant = Base.Invariant

module Lazy = Base.Lazy

module List = Base.List

module Map = Base.Map

module Map_intf = Base.Map_intf

module Maybe_bound = Base.Maybe_bound

module Monad = Base.Monad

module Nativeint = Base.Nativeint

module Option = Base.Option

module Or_error = Base.Or_error

module Ordered_collection_common = Base.Ordered_collection_common

module Ordering = Base.Ordering

module Poly = Base.Poly

module Polymorphic_compare = Base.Polymorphic_compare

module Polymorphic_compare_intf = Base.Polymorphic_compare_intf

module Popcount = Base.Popcount

module Pretty_printer = Base.Pretty_printer

module Printf = Base.Printf

module Linked_queue = Base.Linked_queue

module Queue_intf = Base.Queue_intf

module Random = Base.Random

module Ref = Base.Ref

module Result = Base.Result

module Sequence = Base.Sequence

module Set = Base.Set

module Set_intf = Base.Set_intf

module Sexpable = Base.Sexpable

module Sign = Base.Sign

module Source_code_position = Base.Source_code_position

module Staged = Base.Staged

module String = Base.String

module Stringable = Base.Stringable

module String_dict = Base.String_dict

module Sys = Base.Sys

module T = Base.T

module Type_equal = Base.Type_equal

module Unit = Base.Unit

module Uchar = Base.Uchar

module Validate = Base.Validate

module Variant = Base.Variant

module With_return = Base.With_return

module Word_size = Base.Word_size

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 array_of_sexp : (Base__.Sexplib.Sexp.t ‑> 'a) ‑> Base__.Sexplib.Sexp.t ‑> 'a array

val sexp_of_array : ('a ‑> Base__.Sexplib.Sexp.t) ‑> 'a array ‑> Base__.Sexplib.Sexp.t

val compare_array : ('a ‑> 'a ‑> int) ‑> 'a array ‑> 'a array ‑> int

type bool = Bool.t

val bool_of_sexp : Base__.Sexplib.Sexp.t ‑> bool

val sexp_of_bool : bool ‑> Base__.Sexplib.Sexp.t

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 compare_bool : bool ‑> bool ‑> int

type char = Char.t

val char_of_sexp : Base__.Sexplib.Sexp.t ‑> char

val sexp_of_char : char ‑> Base__.Sexplib.Sexp.t

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 compare_char : char ‑> char ‑> int

type exn = Exn.t

val sexp_of_exn : exn ‑> Base__.Sexplib.Sexp.t

type float = Float.t

val float_of_sexp : Base__.Sexplib.Sexp.t ‑> float

val sexp_of_float : float ‑> Base__.Sexplib.Sexp.t

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 compare_float : float ‑> float ‑> int

type int = Int.t

val int_of_sexp : Base__.Sexplib.Sexp.t ‑> int

val sexp_of_int : int ‑> Base__.Sexplib.Sexp.t

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 compare_int : int ‑> int ‑> int

type int32 = Int32.t

val int32_of_sexp : Base__.Sexplib.Sexp.t ‑> int32

val sexp_of_int32 : int32 ‑> Base__.Sexplib.Sexp.t

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 compare_int32 : int32 ‑> int32 ‑> int

type int64 = Int64.t

val int64_of_sexp : Base__.Sexplib.Sexp.t ‑> int64

val sexp_of_int64 : int64 ‑> Base__.Sexplib.Sexp.t

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 compare_int64 : int64 ‑> int64 ‑> int

type 'a list = 'a List.t

val list_of_sexp : (Base__.Sexplib.Sexp.t ‑> 'a) ‑> Base__.Sexplib.Sexp.t ‑> 'a list

val sexp_of_list : ('a ‑> Base__.Sexplib.Sexp.t) ‑> 'a list ‑> Base__.Sexplib.Sexp.t

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 compare_list : ('a ‑> 'a ‑> int) ‑> 'a list ‑> 'a list ‑> int

type nativeint = Nativeint.t

val nativeint_of_sexp : Base__.Sexplib.Sexp.t ‑> nativeint

val sexp_of_nativeint : nativeint ‑> Base__.Sexplib.Sexp.t

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 compare_nativeint : nativeint ‑> nativeint ‑> int

type 'a option = 'a Option.t

val option_of_sexp : (Base__.Sexplib.Sexp.t ‑> 'a) ‑> Base__.Sexplib.Sexp.t ‑> 'a option

val sexp_of_option : ('a ‑> Base__.Sexplib.Sexp.t) ‑> 'a option ‑> Base__.Sexplib.Sexp.t

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 compare_option : ('a ‑> 'a ‑> int) ‑> 'a option ‑> 'a option ‑> int

type 'a ref = 'a Ref.t

val ref_of_sexp : (Base__.Sexplib.Sexp.t ‑> 'a) ‑> Base__.Sexplib.Sexp.t ‑> 'a ref

val sexp_of_ref : ('a ‑> Base__.Sexplib.Sexp.t) ‑> 'a ref ‑> Base__.Sexplib.Sexp.t

val compare_ref : ('a ‑> 'a ‑> int) ‑> 'a ref ‑> 'a ref ‑> int

type string = String.t

val string_of_sexp : Base__.Sexplib.Sexp.t ‑> string

val sexp_of_string : string ‑> Base__.Sexplib.Sexp.t

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 compare_string : string ‑> string ‑> int

type unit = Unit.t

val unit_of_sexp : Base__.Sexplib.Sexp.t ‑> unit

val sexp_of_unit : unit ‑> Base__.Sexplib.Sexp.t

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 compare_unit : unit ‑> unit ‑> int

type ('a, 'b, 'c) format = ('a, 'b, 'c) Pervasives.format

type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Pervasives.format4

type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Pervasives.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 abs : Base__Int.t ‑> Base__Int.t

val neg : Base__Int.t ‑> Base__Int.t

val zero : Base__Int.t

val of_int_exn : int ‑> 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 ascending : int ‑> int ‑> int

val descending : int ‑> int ‑> int

val compare : int ‑> int ‑> int

val equal : int ‑> int ‑> bool

val max : int ‑> int ‑> int

val min : int ‑> int ‑> int

external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b =

external (&&) : bool ‑> bool ‑> bool =

external (||) : bool ‑> bool ‑> bool =

external not : bool ‑> bool =

external ignore : 'a ‑> unit =

val (^) : String.t ‑> String.t ‑> String.t

external (!) : 'a ref ‑> 'a =

external ref : 'a ‑> 'a ref =

external (:=) : 'a ref ‑> 'a ‑> unit =

val fst : ('a * 'b) ‑> 'a

val snd : ('a * 'b) ‑> 'b

val failwith : string ‑> 'a

val invalid_arg : string ‑> 'a

val raise : exn ‑> 'a

val raise_s : Base.Sexp.t ‑> 'a

val phys_equal : 'a ‑> 'a ‑> bool

module Not_exposed_properly = Base.Not_exposed_properly