Pre_sexp (sexplib.Sexplib.Pre

include Type

type t = Sexplib0.Sexp.t =

| Atom of string

| List of t list

Type of S-expressions

type bigstring = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t

include module type of sig ... end with type t := t

type t = Sexplib0__Sexp.t =

| Atom of string

| List of t list

val t_of_sexp : t ‑> t

val sexp_of_t : t ‑> t

val equal : t ‑> t ‑> bool

val compare : t ‑> t ‑> int

exception Not_found_s of t

exception Of_sexp_error of exn * t

val message : string ‑> (string * t) list ‑> t

val default_indent : int Pervasives.ref

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

val to_string_hum : ?⁠indent:int ‑> t ‑> string

val to_string_mach : t ‑> string

val to_string : t ‑> string

val of_float_style : [ `No_underscores | `Underscores ] Pervasives.ref

val of_int_style : [ `No_underscores | `Underscores ] Pervasives.ref

module Private = Sexplib0__Sexp.Private

include Private

val size : Sexplib0__Sexp.t ‑> int * int

val buffer : unit ‑> Buffer.t

val to_buffer : buf:Buffer.t ‑> Sexplib0__Sexp.t ‑> unit

val to_buffer_hum : buf:Buffer.t ‑> ?⁠indent:int ‑> Sexplib0__Sexp.t ‑> unit

val to_buffer_mach : buf:Buffer.t ‑> Sexplib0__Sexp.t ‑> unit

val to_buffer_gen : buf:'buffer ‑> add_char:('buffer ‑> char ‑> unit) ‑> add_string:('buffer ‑> string ‑> unit) ‑> Sexplib0__Sexp.t ‑> unit

val mach_maybe_esc_str : string ‑> string

val must_escape : string ‑> bool

val esc_str : string ‑> string

val with_new_buffer : Pervasives.out_channel ‑> (Buffer.t ‑> 'a) ‑> unit

val output_hum : Pervasives.out_channel ‑> Sexplib0__Sexp.t ‑> unit

val output_hum_indent : int ‑> Pervasives.out_channel ‑> Sexplib0__Sexp.t ‑> unit

val output_mach : Pervasives.out_channel ‑> Sexplib0__Sexp.t ‑> unit

val output : Pervasives.out_channel ‑> Sexplib0__Sexp.t ‑> unit

module Tmp_file : sig ... end

val save_of_output : ?⁠perm:int ‑> (Pervasives.out_channel ‑> 'a ‑> 'b) ‑> string ‑> 'a ‑> unit

val output_sexp_nl : (Pervasives.out_channel ‑> 'a ‑> 'b) ‑> Pervasives.out_channel ‑> 'a ‑> unit

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

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

val save : ?⁠perm:int ‑> string ‑> Sexplib0__Sexp.t ‑> unit

val output_sexps_nl : (Pervasives.out_channel ‑> 'a ‑> 'b) ‑> Pervasives.out_channel ‑> 'a list ‑> unit

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

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

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

val scan_sexp : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> Type.t

val scan_sexp_opt : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> Type.t option

val scan_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> Type.t list

val scan_rev_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> Type.t list

val get_main_buf : Buffer.t option ‑> Lexing.lexbuf ‑> Parser.token

val scan_fold_sexps : ?⁠buf:Buffer.t ‑> f:('a ‑> Type.t ‑> 'a) ‑> init:'a ‑> Lexing.lexbuf ‑> 'a

val scan_iter_sexps : ?⁠buf:Buffer.t ‑> f:(Type.t ‑> unit) ‑> Lexing.lexbuf ‑> unit

val scan_sexps_conv : ?⁠buf:Buffer.t ‑> f:(Type.t ‑> 'a) ‑> Lexing.lexbuf ‑> 'a list

module Annot : sig ... end

module Parse_pos : sig ... end

module Cont_state : sig ... end

type ('a, 't) 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

type 't parse_state = {

parse_pos : Parse_pos.t;

}

type parse_error = {

err_msg : string;

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

}

exception Parse_error of parse_error

module Parser_output : sig ... end

module Make_parser : functor (T : sig ... end) -> sig ... end

module String_single_sexp : sig ... end

val parse_str : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, Type.t) parse_result

val parse : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, Type.t) parse_result

module String_single_annot : sig ... end

val parse_str_annot : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, Annot.t) parse_result

module Bigstring_single_sexp : sig ... end

val parse_bigstring : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> bigstring ‑> (bigstring, Type.t) parse_result

module Bigstring_single_annot : sig ... end

val parse_bigstring_annot : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> bigstring ‑> (bigstring, Annot.t) parse_result

val mk_this_parse : ?⁠parse_pos:Parse_pos.t ‑> (?⁠parse_pos:Parse_pos.t ‑> ?⁠len:'a ‑> 'b ‑> 'c) ‑> pos:int ‑> len:'a ‑> 'b ‑> 'c

val feed_end_of_input : this_parse:(pos:int ‑> len:int ‑> 'a ‑> ('b, 'c) parse_result) ‑> ws_buf:'a ‑> ('c, Cont_state.t) Pervasives.result

val gen_input_sexp : (?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, 'a) parse_result) ‑> ?⁠parse_pos:Parse_pos.t ‑> Pervasives.in_channel ‑> 'a

val input_sexp : ?⁠parse_pos:Parse_pos.t ‑> Pervasives.in_channel ‑> Type.t

val gen_input_rev_sexps : (?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, 'a) parse_result) ‑> ws_buf:string ‑> ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> 'a list

val input_rev_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> Type.t list

val input_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> Type.t list

val of_string_bigstring : string ‑> (?⁠parse_pos:Parse_pos.t ‑> ?⁠len:'a ‑> 'b ‑> ('c, 'd) parse_result) ‑> 'c ‑> ('b ‑> 'e) ‑> ('b ‑> int ‑> 'e ‑> string) ‑> 'b ‑> 'd

val of_string : string ‑> Type.t

val get_bstr_sub_str : (char, 'a, 'b) Bigarray.Array1.t ‑> int ‑> int ‑> string

val bstr_ws_buf : (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t

val of_bigstring : bigstring ‑> Type.t

val gen_load_rev_sexps : (?⁠parse_pos:'a ‑> ?⁠buf:'b ‑> Pervasives.in_channel ‑> 'c) ‑> ?⁠buf:'b ‑> string ‑> 'c

val load_rev_sexps : ?⁠buf:bytes ‑> string ‑> Type.t list

val load_sexps : ?⁠buf:bytes ‑> string ‑> Type.t list

val gen_load_sexp_loc : string

val gen_load_sexp : (?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, 'a) parse_result) ‑> ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> 'a

val load_sexp : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> Type.t

module Annotated : sig ... end

val load_sexp_conv : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (Type.t ‑> 'a) ‑> [> `Error of exn * Annotated.t | `Result of 'a ]

val raise_conv_exn : file:string ‑> [< `Error of exn * Annotated.t | `Result of 'a ] ‑> 'a

val load_sexp_conv_exn : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (Type.t ‑> 'a) ‑> 'a

val load_sexps_conv : ?⁠buf:bytes ‑> string ‑> (Type.t ‑> 'a) ‑> [> `Error of exn * Annotated.t | `Result of 'a ] list

val load_sexps_conv_exn : ?⁠buf:bytes ‑> string ‑> (Type.t ‑> 'a) ‑> 'a list

val gen_of_string_conv : ('a ‑> Type.t) ‑> ('a ‑> Annotated.t) ‑> 'a ‑> (Type.t ‑> 'b) ‑> [> `Error of exn * Annotated.t | `Result of 'b ]

val of_string_conv : string ‑> (Type.t ‑> 'a) ‑> [> `Error of exn * Annotated.t | `Result of 'a ]

val of_bigstring_conv : bigstring ‑> (Type.t ‑> 'a) ‑> [> `Error of exn * Annotated.t | `Result of 'a ]

module Of_string_conv_exn : sig ... end

val gen_of_string_conv_exn : ('a ‑> Type.t) ‑> 'a ‑> (Type.t ‑> 'b) ‑> 'b

val of_string_conv_exn : string ‑> (Type.t ‑> 'a) ‑> 'a

val of_bigstring_conv_exn : bigstring ‑> (Type.t ‑> 'a) ‑> 'a

val is_unit : t ‑> bool

external sexp_of_t : t ‑> t = "%identity"

external t_of_sexp : t ‑> t = "%identity"

type found = [

| `Found

| `Pos of int * found

]

type search_result = [

| `Not_found

| found

]