Module Base__.Import

include Base__.Import0
include module type of sig ... end with type 'a ref := 'a Stdlib.ref with type ('a, 'b, 'c) format := ('a, 'b, 'c) Stdlib.format with type ('a, 'b, 'c, 'd) format4 := ('a, 'b, 'c, 'd) Stdlib.format4 with type ('a, 'b, 'c, 'd, 'e, 'f) format6 := ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6 with module Array := Shadow_stdlib.Array with module Bool := Shadow_stdlib.Bool with module Buffer := Shadow_stdlib.Buffer with module Bytes := Shadow_stdlib.Bytes with module Char := Shadow_stdlib.Char with module Float := Shadow_stdlib.Float with module Hashtbl := Shadow_stdlib.Hashtbl with module Int := Shadow_stdlib.Int with module Int32 := Shadow_stdlib.Int32 with module Int64 := Shadow_stdlib.Int64 with module Lazy := Shadow_stdlib.Lazy with module List := Shadow_stdlib.List with module Map := Shadow_stdlib.Map with module Nativeint := Shadow_stdlib.Nativeint with module Option := Shadow_stdlib.Option with module Printf := Shadow_stdlib.Printf with module Queue := Shadow_stdlib.Queue with module Random := Shadow_stdlib.Random with module Result := Shadow_stdlib.Result with module Set := Shadow_stdlib.Set with module Stack := Shadow_stdlib.Stack with module String := Shadow_stdlib.String with module Sys := Shadow_stdlib.Sys with module Uchar := Shadow_stdlib.Uchar with module Unit := Shadow_stdlib.Unit
val raise : exn -> 'a
val raise_notrace : exn -> 'a
val invalid_arg : string -> 'a
val failwith : string -> 'a
exception Exit
val (=) : 'a -> 'a -> bool
val (<>) : 'a -> 'a -> bool
val (<) : 'a -> 'a -> bool
val (>) : 'a -> 'a -> bool
val (<=) : 'a -> 'a -> bool
val (>=) : 'a -> 'a -> bool
val compare : 'a -> 'a -> int
val min : 'a -> 'a -> 'a
val max : 'a -> 'a -> 'a
val (==) : 'a -> 'a -> bool
val (!=) : 'a -> 'a -> bool
val not : bool -> bool
val (&&) : bool -> bool -> bool
val (&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val or : bool -> bool -> bool
val __LOC__ : string
val __FILE__ : string
val __LINE__ : int
val __MODULE__ : string
val __POS__ : string * int * int * int
val __LOC_OF__ : 'a -> string * 'a
val __LINE_OF__ : 'a -> int * 'a
val __POS_OF__ : 'a -> (string * int * int * int) * 'a
val (|>) : 'a -> ('a -> 'b) -> 'b
val (@@) : ('a -> 'b) -> 'a -> 'b
val (~-) : int -> int
val (~+) : int -> int
val succ : int -> int
val pred : int -> int
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val max_int : int
val min_int : int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val (lnot) : 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 exp : float -> float
val log : float -> float
val log10 : float -> float
val expm1 : float -> float
val log1p : float -> float
val cos : float -> float
val sin : float -> float
val tan : float -> float
val acos : float -> float
val asin : float -> float
val atan : float -> float
val atan2 : float -> float -> float
val hypot : float -> float -> float
val cosh : float -> float
val sinh : float -> float
val tanh : float -> float
val ceil : float -> float
val floor : float -> float
val abs_float : float -> float
val copysign : float -> float -> float
val mod_float : float -> float -> float
val frexp : float -> float * int
val ldexp : float -> int -> float
val modf : float -> float * float
val float : int -> float
val float_of_int : int -> float
val truncate : float -> int
val int_of_float : float -> int
val infinity : float
val neg_infinity : float
val nan : float
val max_float : float
val min_float : float
val epsilon_float : float
type nonrec fpclass = Stdlib.fpclass =
| FP_normal
| FP_subnormal
| FP_zero
| FP_infinite
| FP_nan
val classify_float : float -> fpclass
val (^) : string -> string -> string
val int_of_char : char -> int
val char_of_int : int -> char
val ignore : 'a -> unit
val string_of_bool : bool -> string
val bool_of_string_opt : string -> bool option
val bool_of_string : string -> bool
val string_of_int : int -> string
val int_of_string_opt : string -> int option
val int_of_string : string -> int
val string_of_float : float -> string
val float_of_string_opt : string -> float option
val float_of_string : string -> float
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val (@) : 'a list -> 'a list -> 'a list
type nonrec in_channel = Stdlib.in_channel
type nonrec out_channel = Stdlib.out_channel
val stdin : in_channel
val stdout : out_channel
val stderr : out_channel
val print_char : char -> unit
val print_string : string -> unit
val print_bytes : bytes -> unit
val print_int : int -> unit
val print_float : float -> unit
val print_endline : string -> unit
val print_newline : unit -> unit
val prerr_char : char -> unit
val prerr_string : string -> unit
val prerr_bytes : bytes -> unit
val prerr_int : int -> unit
val prerr_float : float -> unit
val prerr_endline : string -> unit
val prerr_newline : unit -> unit
val read_line : unit -> string
val read_int_opt : unit -> int option
val read_int : unit -> int
val read_float_opt : unit -> float option
val read_float : unit -> float
type nonrec open_flag = Stdlib.open_flag =
| Open_rdonly
| Open_wronly
| Open_append
| Open_creat
| Open_trunc
| Open_excl
| Open_binary
| Open_text
| Open_nonblock
val open_out : string -> out_channel
val open_out_bin : string -> out_channel
val open_out_gen : open_flag list -> int -> string -> out_channel
val flush : out_channel -> unit
val flush_all : unit -> unit
val output_char : out_channel -> char -> unit
val output_string : out_channel -> string -> unit
val output_bytes : out_channel -> bytes -> unit
val output : out_channel -> bytes -> int -> int -> unit
val output_substring : out_channel -> string -> int -> int -> unit
val output_byte : out_channel -> int -> unit
val output_binary_int : out_channel -> int -> unit
val output_value : out_channel -> 'a -> unit
val seek_out : out_channel -> int -> unit
val pos_out : out_channel -> int
val out_channel_length : out_channel -> int
val close_out : out_channel -> unit
val close_out_noerr : out_channel -> unit
val set_binary_mode_out : out_channel -> bool -> unit
val open_in : string -> in_channel
val open_in_bin : string -> in_channel
val open_in_gen : open_flag list -> int -> string -> in_channel
val input_char : in_channel -> char
val input_line : in_channel -> string
val input : in_channel -> bytes -> int -> int -> int
val really_input : in_channel -> bytes -> int -> int -> unit
val really_input_string : in_channel -> int -> string
val input_byte : in_channel -> int
val input_binary_int : in_channel -> int
val input_value : in_channel -> 'a
val seek_in : in_channel -> int -> unit
val pos_in : in_channel -> int
val in_channel_length : in_channel -> int
val close_in : in_channel -> unit
val close_in_noerr : in_channel -> unit
val set_binary_mode_in : in_channel -> bool -> unit
module LargeFile = Stdlib.LargeFile
type nonrec 'a ref = 'a Stdlib.ref = {
mutable contents : 'a;
}
val ref : 'a -> 'a ref
val (!) : 'a ref -> 'a
val (:=) : 'a ref -> 'a -> unit
val incr : int ref -> unit
val decr : int ref -> unit
type nonrec ('a, 'b) result = ('a, 'b) Stdlib.result =
| Ok of 'a
| Error of 'b
type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6
type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4
val string_of_format : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> string
val format_of_string : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('a, 'b, 'c, 'd, 'e, 'f) format6
val (^^) : ('a, 'b, 'c, 'd, 'e, 'f) format6 -> ('f, 'b, 'c, 'e, 'g, 'h) format6 -> ('a, 'b, 'c, 'd, 'g, 'h) 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 Arg = Stdlib.Arg
module Array = Stdlib.Array
module ArrayLabels = Stdlib.ArrayLabels
module Bool = Stdlib.Bool
module Buffer = Stdlib.Buffer
module Bytes = Stdlib.Bytes
module BytesLabels = Stdlib.BytesLabels
module Callback = Stdlib.Callback
module Char = Stdlib.Char
module Complex = Stdlib.Complex
module Digest = Stdlib.Digest
module Ephemeron = Stdlib.Ephemeron
module Filename = Stdlib.Filename
module Float = Stdlib.Float
module Format = Stdlib.Format
module Fun = Stdlib.Fun
module Gc = Stdlib.Gc
module Genlex = Stdlib.Genlex
module Hashtbl = Stdlib.Hashtbl
module Int = Stdlib.Int
module Int32 = Stdlib.Int32
module Int64 = Stdlib.Int64
module Lazy = Stdlib.Lazy
module Lexing = Stdlib.Lexing
module List = Stdlib.List
module ListLabels = Stdlib.ListLabels
module Map = Stdlib.Map
module Marshal = Stdlib.Marshal
module MoreLabels = Stdlib.MoreLabels
module Nativeint = Stdlib.Nativeint
module Obj = Stdlib.Obj
module Oo = Stdlib.Oo
module Option = Stdlib.Option
module Parsing = Stdlib.Parsing
module Pervasives = Stdlib.Pervasives
module Printexc = Stdlib.Printexc
module Printf = Stdlib.Printf
module Queue = Stdlib.Queue
module Random = Stdlib.Random
module Result = Stdlib.Result
module Scanf = Stdlib.Scanf
module Seq = Stdlib.Seq
module Set = Stdlib.Set
module Spacetime = Stdlib.Spacetime
module Stack = Stdlib.Stack
module StdLabels = Stdlib.StdLabels
module Stream = Stdlib.Stream
module String = Stdlib.String
module StringLabels = Stdlib.StringLabels
module Sys = Stdlib.Sys
module Uchar = Stdlib.Uchar
module Unit = Stdlib.Unit
module Weak = Stdlib.Weak
exception Not_found
type 'a ref = 'a Caml.ref = {
mutable contents : 'a;
}
module Caml = Base__.Import0.Caml
val (|>) : 'a -> ('a -> 'b) -> 'b
val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val bool_to_int : bool -> int
val ignore : _ -> unit
val (!=) : 'a -> 'a -> bool
val (*) : int -> int -> int
val (**) : float -> float -> float
val (*.) : float -> float -> float
val (+) : int -> int -> int
val (+.) : float -> float -> float
val (-) : int -> int -> int
val (-.) : float -> float -> float
val (/) : int -> int -> int
val (/.) : float -> float -> float
module Poly = Base__.Poly0
module Int_replace_polymorphic_compare = Base__.Import0.Int_replace_polymorphic_compare
include Int_replace_polymorphic_compare
val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
module Int32_replace_polymorphic_compare = Base__.Import0.Int32_replace_polymorphic_compare
module Int64_replace_polymorphic_compare = Base__.Import0.Int64_replace_polymorphic_compare
module Nativeint_replace_polymorphic_compare = Base__.Import0.Nativeint_replace_polymorphic_compare
module Bool_replace_polymorphic_compare = Base__.Import0.Bool_replace_polymorphic_compare
module Char_replace_polymorphic_compare = Base__.Import0.Char_replace_polymorphic_compare
module Uchar_replace_polymorphic_compare = Base__.Import0.Uchar_replace_polymorphic_compare
module Float_replace_polymorphic_compare = Base__.Import0.Float_replace_polymorphic_compare
module String_replace_polymorphic_compare = Base__.Import0.String_replace_polymorphic_compare
module Bytes_replace_polymorphic_compare = Base__.Import0.Bytes_replace_polymorphic_compare
val (:=) : 'a ref -> 'a -> unit
val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (@) : 'a list -> 'a list -> 'a list
val (^) : string -> string -> string
val (~-) : int -> int
val (~-.) : float -> float
val (asr) : int -> int -> int
val (land) : int -> int -> int
val (lnot) : int -> int
val (lor) : int -> int -> int
val (lsl) : int -> int -> int
val (lsr) : int -> int -> int
val (lxor) : int -> int -> int
val (mod) : int -> int -> int
val abs : int -> int
val failwith : string -> 'a
val fst : ('a * 'b) -> 'a
val invalid_arg : string -> 'a
val snd : ('a * 'b) -> 'b
val raise : exn -> _
val phys_equal : 'a -> 'a -> bool
val decr : int Caml.ref -> unit
val incr : int Caml.ref -> unit
val float_of_string : string -> float
val am_testing : unit -> bool
val am_testing : bool
include Sexplib0.Sexp_conv
type sexp_bool = bool

Dummy definitions for "optional" options, lists, and for opaque types

type 'a sexp_option = 'a option
type 'a sexp_list = 'a list
type 'a sexp_array = 'a array
type 'a sexp_opaque = 'a
Conversion of OCaml-values to S-expressions
val default_string_of_float : (float -> string) Stdlib.ref

default_string_of_float reference to the default function used to convert floats to strings.

Initially set to fun n -> sprintf "%.20G" n.

val write_old_option_format : bool Stdlib.ref

write_old_option_format reference for the default option format used to write option values. If set to true, the old-style option format will be used, the new-style one otherwise.

Initially set to true.

val read_old_option_format : bool Stdlib.ref

read_old_option_format reference for the default option format used to read option values. Of_sexp_error will be raised with old-style option values if this reference is set to false. Reading new-style option values is always supported. Using a global reference instead of changing the converter calling conventions is the only way to avoid breaking old code with the standard macros.

Initially set to true.

val list_map : ('a -> 'b) -> 'a list -> 'b list

We re-export a tail recursive map function, because some modules override the standard library functions (e.g. StdLabels) which wrecks havoc with the camlp4 extension.

val sexp_of_unit : unit -> Sexplib0.Sexp.t

sexp_of_unit () converts a value of type unit to an S-expression.

val sexp_of_bool : bool -> Sexplib0.Sexp.t

sexp_of_bool b converts the value x of type bool to an S-expression.

val sexp_of_string : string -> Sexplib0.Sexp.t

sexp_of_bool str converts the value str of type string to an S-expression.

val sexp_of_bytes : bytes -> Sexplib0.Sexp.t

sexp_of_bool str converts the value str of type bytes to an S-expression.

val sexp_of_char : char -> Sexplib0.Sexp.t

sexp_of_char c converts the value c of type char to an S-expression.

val sexp_of_int : int -> Sexplib0.Sexp.t

sexp_of_int n converts the value n of type int to an S-expression.

val sexp_of_float : float -> Sexplib0.Sexp.t

sexp_of_float n converts the value n of type float to an S-expression.

val sexp_of_int32 : int32 -> Sexplib0.Sexp.t

sexp_of_int32 n converts the value n of type int32 to an S-expression.

val sexp_of_int64 : int64 -> Sexplib0.Sexp.t

sexp_of_int64 n converts the value n of type int64 to an S-expression.

val sexp_of_nativeint : nativeint -> Sexplib0.Sexp.t

sexp_of_nativeint n converts the value n of type nativeint to an S-expression.

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

sexp_of_ref conv r converts the value r of type 'a ref to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_lazy_t : ('a -> Sexplib0.Sexp.t) -> 'a lazy_t -> Sexplib0.Sexp.t

sexp_of_lazy_t conv l converts the value l of type 'a lazy_t to an S-expression. Uses conv to convert values of type 'a to an S-expression.

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

sexp_of_option conv opt converts the value opt of type 'a option to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_pair : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a * 'b) -> Sexplib0.Sexp.t

sexp_of_pair conv1 conv2 pair converts a pair to an S-expression. It uses its first argument to convert the first element of the pair, and its second argument to convert the second element of the pair.

val sexp_of_triple : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('c -> Sexplib0.Sexp.t) -> ('a * 'b * 'c) -> Sexplib0.Sexp.t

sexp_of_triple conv1 conv2 conv3 triple converts a triple to an S-expression using conv1, conv2, and conv3 to convert its elements.

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

sexp_of_list conv lst converts the value lst of type 'a list to an S-expression. Uses conv to convert values of type 'a to an S-expression.

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

sexp_of_array conv ar converts the value ar of type 'a array to an S-expression. Uses conv to convert values of type 'a to an S-expression.

val sexp_of_hashtbl : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) Stdlib.Hashtbl.t -> Sexplib0.Sexp.t

sexp_of_hashtbl conv_key conv_value htbl converts the value htbl of type ('a, 'b) Hashtbl.t to an S-expression. Uses conv_key to convert the hashtable keys of type 'a, and conv_value to convert hashtable values of type 'b to S-expressions.

val sexp_of_opaque : 'a -> Sexplib0.Sexp.t

sexp_of_opaque x converts the value x of opaque type to an S-expression. This means the user need not provide converters, but the result cannot be interpreted.

val sexp_of_fun : ('a -> 'b) -> Sexplib0.Sexp.t

sexp_of_fun f converts the value f of function type to a dummy S-expression. Functions cannot be serialized as S-expressions, but at least a placeholder can be generated for pretty-printing.

Conversion of S-expressions to OCaml-values
exception Of_sexp_error of exn * Sexplib0.Sexp.t

Of_sexp_error (exn, sexp) the exception raised when an S-expression could not be successfully converted to an OCaml-value.

val record_check_extra_fields : bool Stdlib.ref

record_check_extra_fields checks for extra (= unknown) fields in record S-expressions.

val of_sexp_error : string -> Sexplib0.Sexp.t -> 'a

of_sexp_error reason sexp

raises Of_sexp_error

(Failure reason, sexp).

val of_sexp_error_exn : exn -> Sexplib0.Sexp.t -> 'a

of_sexp_error exc sexp

raises Of_sexp_error

(exc, sexp).

val unit_of_sexp : Sexplib0.Sexp.t -> unit

unit_of_sexp sexp converts S-expression sexp to a value of type unit.

val bool_of_sexp : Sexplib0.Sexp.t -> bool

bool_of_sexp sexp converts S-expression sexp to a value of type bool.

val string_of_sexp : Sexplib0.Sexp.t -> string

string_of_sexp sexp converts S-expression sexp to a value of type string.

val bytes_of_sexp : Sexplib0.Sexp.t -> bytes

bytes_of_sexp sexp converts S-expression sexp to a value of type bytes.

val char_of_sexp : Sexplib0.Sexp.t -> char

char_of_sexp sexp converts S-expression sexp to a value of type char.

val int_of_sexp : Sexplib0.Sexp.t -> int

int_of_sexp sexp converts S-expression sexp to a value of type int.

val float_of_sexp : Sexplib0.Sexp.t -> float

float_of_sexp sexp converts S-expression sexp to a value of type float.

val int32_of_sexp : Sexplib0.Sexp.t -> int32

int32_of_sexp sexp converts S-expression sexp to a value of type int32.

val int64_of_sexp : Sexplib0.Sexp.t -> int64

int64_of_sexp sexp converts S-expression sexp to a value of type int64.

val nativeint_of_sexp : Sexplib0.Sexp.t -> nativeint

nativeint_of_sexp sexp converts S-expression sexp to a value of type nativeint.

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

ref_of_sexp conv sexp converts S-expression sexp to a value of type 'a ref using conversion function conv, which converts an S-expression to a value of type 'a.

val lazy_t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a lazy_t

lazy_t_of_sexp conv sexp converts S-expression sexp to a value of type 'a lazy_t using conversion function conv, which converts an S-expression to a value of type 'a.

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

option_of_sexp conv sexp converts S-expression sexp to a value of type 'a option using conversion function conv, which converts an S-expression to a value of type 'a.

val pair_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> 'a * 'b

pair_of_sexp conv1 conv2 sexp converts S-expression sexp to a pair of type 'a * 'b using conversion functions conv1 and conv2, which convert S-expressions to values of type 'a and 'b respectively.

val triple_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> (Sexplib0.Sexp.t -> 'c) -> Sexplib0.Sexp.t -> 'a * 'b * 'c

triple_of_sexp conv1 conv2 conv3 sexp converts S-expression sexp to a triple of type 'a * 'b * 'c using conversion functions conv1, conv2, and conv3, which convert S-expressions to values of type 'a, 'b, and 'c respectively.

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

list_of_sexp conv sexp converts S-expression sexp to a value of type 'a list using conversion function conv, which converts an S-expression to a value of type 'a.

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

array_of_sexp conv sexp converts S-expression sexp to a value of type 'a array using conversion function conv, which converts an S-expression to a value of type 'a.

val hashtbl_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) Stdlib.Hashtbl.t

hashtbl_of_sexp conv_key conv_value sexp converts S-expression sexp to a value of type ('a, 'b) Hashtbl.t using conversion function conv_key, which converts an S-expression to hashtable key of type 'a, and function conv_value, which converts an S-expression to hashtable value of type 'b.

val opaque_of_sexp : Sexplib0.Sexp.t -> 'a

opaque_of_sexp sexp

raises Of_sexp_error

when attempting to convert an S-expression to an opaque value.

val fun_of_sexp : Sexplib0.Sexp.t -> 'a

fun_of_sexp sexp

raises Of_sexp_error

when attempting to convert an S-expression to a function.

val sexp_of_exn : exn -> Sexplib0.Sexp.t

sexp_of_exn exc converts exception exc to an S-expression. If no suitable converter is found, the standard converter in Printexc will be used to generate an atomic S-expression.

val sexp_of_exn_opt : exn -> Sexplib0.Sexp.t option

sexp_of_exn_opt exc converts exception exc to Some sexp. If no suitable converter is found, None is returned instead.

module Exn_converter = Sexplib0.Sexp_conv.Exn_converter
include Base.Hash.Builtin
val hash_fold_nativeint : nativeint Base.Hash.folder
val hash_fold_int64 : int64 Base.Hash.folder
val hash_fold_int32 : int32 Base.Hash.folder
val hash_fold_char : char Base.Hash.folder
val hash_fold_int : int Base.Hash.folder
val hash_fold_bool : bool Base.Hash.folder
val hash_fold_string : string Base.Hash.folder
val hash_fold_float : float Base.Hash.folder
val hash_fold_unit : unit Base.Hash.folder
val hash_fold_option : 'a Base.Hash.folder -> 'a option Base.Hash.folder
val hash_fold_list : 'a Base.Hash.folder -> 'a list Base.Hash.folder
val hash_fold_lazy_t : 'a Base.Hash.folder -> 'a lazy_t Base.Hash.folder
val hash_fold_ref_frozen : 'a Base.Hash.folder -> 'a Base__.Import0.ref Base.Hash.folder

Hash support for array and ref is provided, but is potentially DANGEROUS, since it incorporates the current contents of the array/ref into the hash value. Because of this we add a _frozen suffix to the function name.

Hash support for string is also potentially DANGEROUS, but strings are mutated less often, so we don't append _frozen to it.

Also note that we don't support bytes.

val hash_fold_array_frozen : 'a Base.Hash.folder -> 'a array Base.Hash.folder
val hash_nativeint : nativeint -> Base.Hash.hash_value
val hash_int64 : int64 -> Base.Hash.hash_value
val hash_int32 : int32 -> Base.Hash.hash_value
val hash_char : char -> Base.Hash.hash_value
val hash_int : int -> Base.Hash.hash_value
val hash_bool : bool -> Base.Hash.hash_value
val hash_string : string -> Base.Hash.hash_value
val hash_float : float -> Base.Hash.hash_value
val hash_unit : unit -> Base.Hash.hash_value
include Base__.Ppx_compare_lib.Builtin
val compare_bool : bool Base__.Ppx_compare_lib.compare
val compare_char : char Base__.Ppx_compare_lib.compare
val compare_float : float Base__.Ppx_compare_lib.compare
val compare_int : int Base__.Ppx_compare_lib.compare
val compare_int32 : int32 Base__.Ppx_compare_lib.compare
val compare_int64 : int64 Base__.Ppx_compare_lib.compare
val compare_nativeint : nativeint Base__.Ppx_compare_lib.compare
val compare_string : string Base__.Ppx_compare_lib.compare
val compare_unit : unit Base__.Ppx_compare_lib.compare
val compare_array : 'a Base__.Ppx_compare_lib.compare -> 'a array Base__.Ppx_compare_lib.compare
val compare_list : 'a Base__.Ppx_compare_lib.compare -> 'a list Base__.Ppx_compare_lib.compare
val compare_option : 'a Base__.Ppx_compare_lib.compare -> 'a option Base__.Ppx_compare_lib.compare
val compare_ref : 'a Base__.Ppx_compare_lib.compare -> 'a Stdlib.ref Base__.Ppx_compare_lib.compare
val equal_bool : bool Base__.Ppx_compare_lib.equal
val equal_char : char Base__.Ppx_compare_lib.equal
val equal_float : float Base__.Ppx_compare_lib.equal
val equal_int : int Base__.Ppx_compare_lib.equal
val equal_int32 : int32 Base__.Ppx_compare_lib.equal
val equal_int64 : int64 Base__.Ppx_compare_lib.equal
val equal_nativeint : nativeint Base__.Ppx_compare_lib.equal
val equal_string : string Base__.Ppx_compare_lib.equal
val equal_unit : unit Base__.Ppx_compare_lib.equal
val equal_array : 'a Base__.Ppx_compare_lib.equal -> 'a array Base__.Ppx_compare_lib.equal
val equal_list : 'a Base__.Ppx_compare_lib.equal -> 'a list Base__.Ppx_compare_lib.equal
val equal_option : 'a Base__.Ppx_compare_lib.equal -> 'a option Base__.Ppx_compare_lib.equal
val equal_ref : 'a Base__.Ppx_compare_lib.equal -> 'a Stdlib.ref Base__.Ppx_compare_lib.equal
include Int_replace_polymorphic_compare
val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
exception Not_found_s of Sexplib0.Sexp.t