`include module type of sig ... end`
`type t``= Base.Sexp.t``=`

`|` `Atom of Core_kernel__.Import.string`
`|` `List of t Core_kernel__.Import.list`

``
`val bin_t : t Bin_prot.Type_class.t`
`val bin_read_t : t Bin_prot.Read.reader`
`val __bin_read_t__ : (Core_kernel__.Import.int ‑> t) Bin_prot.Read.reader`
`val bin_reader_t : t Bin_prot.Type_class.reader`
`val bin_size_t : t Bin_prot.Size.sizer`
`val bin_write_t : t Bin_prot.Write.writer`
`val bin_writer_t : t Bin_prot.Type_class.writer`
`val bin_shape_t : Bin_prot.Shape.t`
`val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state`
`val hash : t ‑> Base.Hash.hash_value`
`module O = Core_kernel__Sexp.O`
`val (>=) : t ‑> t ‑> bool`
`val (<=) : t ‑> t ‑> bool`
`val (=) : t ‑> t ‑> bool`
`val (>) : t ‑> t ‑> bool`
`val (<) : t ‑> t ‑> bool`
`val (<>) : t ‑> t ‑> bool`
`val equal : t ‑> t ‑> bool`
`val min : t ‑> t ‑> t`
`val max : t ‑> t ‑> t`
`val ascending : t ‑> t ‑> int`
`val descending : t ‑> t ‑> int`
`val between : t ‑> low:t ‑> high:t ‑> bool`
`val clamp_exn : t ‑> min:t ‑> max:t ‑> t`
`val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t`
`type comparator_witness``= Core_kernel__Sexp.comparator_witness```
`val comparator : (t, comparator_witness) Base.Comparator.comparator`
`val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`module Replace_polymorphic_compare = Core_kernel__Sexp.Replace_polymorphic_compare`
`module Map = Core_kernel__Sexp.Map`
`module Set = Core_kernel__Sexp.Set`
`val gen : t Core_kernel.Quickcheck.Generator.t`
`val obs : t Core_kernel.Quickcheck.Observer.t`
`val shrinker : t Core_kernel.Quickcheck.Shrinker.t`
`type bigstring``= (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t```
`val compare : t ‑> t ‑> int`
`val default_indent : int Pervasives.ref`
`val size : t ‑> int * int`
`val scan_sexp : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t`
`val scan_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t list`
`val scan_rev_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t list`
`val scan_sexp_opt : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t option`
`val scan_iter_sexps : ?⁠buf:Buffer.t ‑> f:(t ‑> unit) ‑> Lexing.lexbuf ‑> unit`
`val scan_fold_sexps : ?⁠buf:Buffer.t ‑> f:('a ‑> t ‑> 'a) ‑> init:'a ‑> Lexing.lexbuf ‑> 'a`
`val scan_sexps_conv : ?⁠buf:Buffer.t ‑> f:(t ‑> 'a) ‑> Lexing.lexbuf ‑> 'a list`
`module Parse_pos = Core_kernel__Sexp.Parse_pos`
`module Cont_state = Core_kernel__Sexp.Cont_state`
`type ('a, 't) parse_result``= ('a, 't) Sexplib.Pre_sexp.parse_result``=`

`|` `Done of 't * Parse_pos.t`
`|` `Cont of Cont_state.t * ('a, 't) parse_fun`

``
`type ('a, 't) parse_fun``= pos:int ‑> len:int ‑> 'a ‑> ('a, 't) parse_result```
`module Annotated = Core_kernel__Sexp.Annotated`
`type 't parse_state``= private 't Sexplib.Pre_sexp.parse_state``=` `{`

`parse_pos : Parse_pos.t;`

`}```
`type parse_error``= Sexplib.Pre_sexp.parse_error``=` `{`

`err_msg : string;`
`parse_state : [ `Annot of Annotated.stack parse_state | `Sexp of t list list parse_state ];`

`}```
`exception` `Parse_error of parse_error`
`val parse : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, t) parse_result`
`val parse_bigstring : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> bigstring ‑> (bigstring, t) parse_result`
`val input_sexp : ?⁠parse_pos:Parse_pos.t ‑> Pervasives.in_channel ‑> t`
`val input_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> t list`
`val input_rev_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> t list`
`val load_sexp : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> t`
`val load_sexps : ?⁠buf:bytes ‑> string ‑> t list`
`val load_rev_sexps : ?⁠buf:bytes ‑> string ‑> t list`
`val load_sexp_conv : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a Annotated.conv`
`val load_sexp_conv_exn : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a`
`val load_sexps_conv : ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a Annotated.conv list`
`val load_sexps_conv_exn : ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a list`
`val output_hum : Pervasives.out_channel ‑> t ‑> unit`
`val output_hum_indent : int ‑> Pervasives.out_channel ‑> t ‑> unit`
`val output_mach : Pervasives.out_channel ‑> t ‑> unit`
`val output : Pervasives.out_channel ‑> t ‑> unit`
`val save_hum : ?⁠perm:int ‑> string ‑> t ‑> unit`
`val save_mach : ?⁠perm:int ‑> string ‑> t ‑> unit`
`val save : ?⁠perm:int ‑> string ‑> t ‑> unit`
`val save_sexps_hum : ?⁠perm:int ‑> string ‑> t list ‑> unit`
`val save_sexps_mach : ?⁠perm:int ‑> string ‑> t list ‑> unit`
`val save_sexps : ?⁠perm:int ‑> string ‑> t list ‑> unit`
`val pp_hum : Format.formatter ‑> t ‑> unit`
`val pp_hum_indent : int ‑> Format.formatter ‑> t ‑> unit`
`val pp_mach : Format.formatter ‑> t ‑> unit`
`val pp : Format.formatter ‑> t ‑> unit`
`module Of_string_conv_exn = Core_kernel__Sexp.Of_string_conv_exn`
`val of_string : string ‑> t`
`val of_string_conv : string ‑> (t ‑> 'a) ‑> 'a Annotated.conv`
`val of_string_conv_exn : string ‑> (t ‑> 'a) ‑> 'a`
`val of_bigstring : bigstring ‑> t`
`val of_bigstring_conv : bigstring ‑> (t ‑> 'a) ‑> 'a Annotated.conv`
`val of_bigstring_conv_exn : bigstring ‑> (t ‑> 'a) ‑> 'a`
`val to_string_hum : ?⁠indent:int ‑> t ‑> string`
`val to_string_mach : t ‑> string`
`val to_string : t ‑> string`
`val to_buffer_hum : buf:Buffer.t ‑> ?⁠indent:int ‑> t ‑> unit`
`val to_buffer_mach : buf:Buffer.t ‑> t ‑> unit`
`val to_buffer : buf:Buffer.t ‑> t ‑> unit`
`val to_buffer_gen : buf:'buffer ‑> add_char:('buffer ‑> char ‑> unit) ‑> add_string:('buffer ‑> string ‑> unit) ‑> t ‑> unit`
`val unit : t`
`val is_unit : t ‑> bool`
`val sexp_of_t : t ‑> t`
`val t_of_sexp : t ‑> t`
`type found` = `[`

`|` ``Found`
`|` ``Pos of int * found`

`]```
`type search_result` = `[`

`|` ``Found`
`|` ``Not_found`
`|` ``Pos of int * found`

`]```
`val search_physical : t ‑> contained:t ‑> search_result`
`val subst_found : t ‑> subst:t ‑> found ‑> t`
`module With_layout = Core_kernel__Sexp.With_layout`
`exception` `Of_sexp_error of Core_kernel__.Import.exn * t`
`val of_float_style : [ `No_underscores | `Underscores ] Core_kernel__.Import.ref`
`val of_int_style : [ `No_underscores | `Underscores ] Core_kernel__.Import.ref`
`type 'a no_raise``= 'a```
`val bin_no_raise : 'a Bin_prot.Type_class.t ‑> 'a no_raise Bin_prot.Type_class.t`
`val bin_read_no_raise : 'a Bin_prot.Read.reader ‑> 'a no_raise Bin_prot.Read.reader`
`val __bin_read_no_raise__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a no_raise) Bin_prot.Read.reader`
`val bin_reader_no_raise : 'a Bin_prot.Type_class.reader ‑> 'a no_raise Bin_prot.Type_class.reader`
`val bin_size_no_raise : 'a Bin_prot.Size.sizer ‑> 'a no_raise Bin_prot.Size.sizer`
`val bin_write_no_raise : 'a Bin_prot.Write.writer ‑> 'a no_raise Bin_prot.Write.writer`
`val bin_writer_no_raise : 'a Bin_prot.Type_class.writer ‑> 'a no_raise Bin_prot.Type_class.writer`
`val bin_shape_no_raise : Bin_prot.Shape.t ‑> Bin_prot.Shape.t`
`val no_raise_of_sexp : (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a no_raise`
`val sexp_of_no_raise : ('a ‑> Base.Sexp.t) ‑> 'a no_raise ‑> Base.Sexp.t`
`module Sexp_maybe = Core_kernel__Sexp.Sexp_maybe`
`module With_text = Core_kernel__Sexp.With_text`
`val of_sexp_allow_extra_fields : (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a`
`val save : ?⁠perm:int ‑> string ‑> t ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexp ~hum:false to avoid blocking.

`val save_hum : ?⁠perm:int ‑> string ‑> t ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexp ~hum:true to avoid blocking.

`val save_mach : ?⁠perm:int ‑> string ‑> t ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexp ~hum:false to avoid blocking.

`val save_sexps : ?⁠perm:int ‑> string ‑> t list ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexps ~hum:false to avoid blocking.

`val save_sexps_hum : ?⁠perm:int ‑> string ‑> t list ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexps ~hum:true to avoid blocking.

`val save_sexps_mach : ?⁠perm:int ‑> string ‑> t list ‑> unit`

- Deprecated [since 2015-12] Use Writer.save_sexps ~hum:false to avoid blocking.