Import (base.Base_

include Base__.Import0

include module type of sig ... end with type a ref := a Pervasives.ref with type (a, b, c) format := (a, b, c) Pervasives.format with type (a, b, c, d) format4 := (a, b, c, d) Pervasives.format4 with type (a, b, c, d, e, f) format6 := (a, b, c, d, e, f) Pervasives.format6 with module Pervasives := Pervasives with module Array := Caml.Array with module Buffer := Caml.Buffer with module Char := Caml.Char with module Hashtbl := Caml.Hashtbl with module Int32 := Caml.Int32 with module Int64 := Caml.Int64 with module Lazy := Caml.Lazy with module List := Caml.List with module Map := Caml.Map with module Nativeint := Caml.Nativeint with module Printf := Caml.Printf with module Random := Caml.Random with module Set := Caml.Set with module String := Caml.String with module Sys := Caml.Sys with module Uchar := Caml.Uchar

module Arg = Arg

module Array = Array

module ArrayLabels = ArrayLabels

module Buffer = Buffer

module Bytes = Bytes

module BytesLabels = BytesLabels

module Callback = Callback

module Char = Char

module Complex = Complex

module Digest = Digest

module Ephemeron = Ephemeron

module Filename = Filename

module Format = Format

module Gc = Gc

module Genlex = Genlex

module Hashtbl = Hashtbl

module Int32 = Int32

module Int64 = Int64

module Lazy = Lazy

module Lexing = Lexing

module List = List

module ListLabels = ListLabels

module Map = Map

module Marshal = Marshal

module MoreLabels = MoreLabels

module Nativeint = Nativeint

module Obj = Obj

module Oo = Oo

module Parsing = Parsing

module Pervasives = Pervasives

module Printexc = Printexc

module Printf = Printf

module Queue = Queue

module Random = Random

module Scanf = Scanf

module Set = Set

module Sort = Sort

module Spacetime = Spacetime

module Stack = Stack

module StdLabels = StdLabels

module Stream = Stream

module String = String

module StringLabels = StringLabels

module Sys = Sys

module Uchar = Uchar

module Weak = Weak

external raise : exn ‑> 'a =

external raise_notrace : exn ‑> 'a =

val invalid_arg : string ‑> 'a

val failwith : string ‑> 'a

exception Exit

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

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

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

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

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

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

external compare : 'a ‑> 'a ‑> int =

val min : 'a ‑> 'a ‑> 'a

val max : 'a ‑> 'a ‑> 'a

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

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

external not : bool ‑> bool =

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

external (&) : bool ‑> bool ‑> 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 ‑> ('a ‑> 'b) ‑> 'b =

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

external (~-) : int ‑> int =

external (~+) : int ‑> int =

external succ : int ‑> int =

external pred : int ‑> int =

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

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

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

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

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

val abs : int ‑> int

val max_int : int

val min_int : int

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

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

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

val (lnot) : int ‑> int

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

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

external (asr) : int ‑> 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 =

val (^) : string ‑> string ‑> string

external int_of_char : char ‑> int =

val char_of_int : int ‑> char

external ignore : 'a ‑> unit =

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 =

external fst : ('a * 'b) ‑> 'a =

external snd : ('a * 'b) ‑> 'b =

val (@) : 'a list ‑> 'a list ‑> 'a list

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

type 'a ref = 'a Pervasives.ref = {

mutable contents : 'a;

}

external ref : 'a ‑> 'a ref =

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

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

external incr : int ref ‑> unit =

external decr : int ref ‑> unit =

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

| Ok of 'a

| Error of 'b

type ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6

type ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'c, 'c, 'd) format6

type ('a, 'b, 'c) format = ('a, 'b, 'c, 'c) format4

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

external 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

type 'a ref = 'a Caml.ref = {

mutable contents : 'a;

}

module Caml = Base__.Import0.Caml

external (|>) : 'a ‑> ('a ‑> 'b) ‑> 'b = "%revapply"

external (&&) : bool ‑> bool ‑> bool = "%sequand"

external (||) : bool ‑> bool ‑> bool = "%sequor"

external not : bool ‑> bool = "%boolnot"

external ignore : _ ‑> unit = "%ignore"

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 Polymorphic_compare = Base__.Import0.Polymorphic_compare

module Poly = Polymorphic_compare

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

val (<.) : float ‑> float ‑> bool

val (<=.) : float ‑> float ‑> bool

val (=.) : float ‑> float ‑> bool

val (>.) : float ‑> float ‑> bool

val (>=.) : float ‑> float ‑> bool

external (:=) : 'a ref ‑> 'a ‑> unit = "%setfield0"

external (!) : 'a ref ‑> 'a = "%field0"

external ref : 'a ‑> 'a ref = "%makemutable"

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 decr : int Caml.ref ‑> unit

val exit : int ‑> 'a

val failwith : string ‑> 'a

val float_of_int : int ‑> float

val float_of_string : string ‑> float

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

val incr : int Caml.ref ‑> unit

val int_of_float : float ‑> int

val invalid_arg : string ‑> 'a

val max_int : int

val min_int : int

val raise : exn ‑> 'a

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

val succ : int ‑> int

val string_of_int : int ‑> string

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

external am_testing : unit ‑> bool = "Base_am_testing"

val am_testing : bool

include Sexplib0.Sexp_conv

Utility Module for S-expression Conversions

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) Pervasives.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 Pervasives.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 Pervasives.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_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 Pervasives.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) 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 Pervasives.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 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 Pervasives.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) 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.

Exception converters

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

external ignore : _ ‑> unit = "%ignore"

external (=) : 'a ‑> 'a ‑> bool = "%equal"