Module Sexplib.Pre_sexp

module Sexplib = Sexplib0
module Conv = Sexplib0.Sexp_conv
include Type
type t = Sexplib0.Sexp.t =
| Atom of string
| List of t list

Type of S-expressions

type bigstring = (char, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout) Stdlib.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 Stdlib.ref
val pp_hum : Stdlib.Format.formatter -> t -> unit
val pp_hum_indent : int -> Stdlib.Format.formatter -> t -> unit
val pp_mach : Stdlib.Format.formatter -> t -> unit
val pp : Stdlib.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 ] Stdlib.ref
val of_int_style : [ `No_underscores | `Underscores ] Stdlib.ref
include Private
val size : Sexplib0__Sexp.t -> int * int
val buffer : unit -> Stdlib.Buffer.t
val to_buffer : buf:Stdlib.Buffer.t -> Sexplib0__Sexp.t -> unit
val to_buffer_hum : buf:Stdlib.Buffer.t -> ?⁠indent:int -> Sexplib0__Sexp.t -> unit
val to_buffer_mach : buf:Stdlib.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 : Stdlib.out_channel -> (Stdlib.Buffer.t -> 'a) -> unit
val output_hum : Stdlib.out_channel -> Sexplib0__Sexp.t -> unit
val output_hum_indent : int -> Stdlib.out_channel -> Sexplib0__Sexp.t -> unit
val output_mach : Stdlib.out_channel -> Sexplib0__Sexp.t -> unit
val output : Stdlib.out_channel -> Sexplib0__Sexp.t -> unit
module Tmp_file : sig ... end
val save_of_output : ?⁠perm:int -> (Stdlib.out_channel -> 'a -> 'b) -> string -> 'a -> unit
val output_sexp_nl : (Stdlib.out_channel -> 'a -> 'b) -> Stdlib.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 : (Stdlib.out_channel -> 'a -> 'b) -> Stdlib.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:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> Type.t
val scan_sexp_opt : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> Type.t option
val scan_sexps : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> Type.t list
val scan_rev_sexps : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> Type.t list
val get_main_buf : Stdlib.Buffer.t option -> Stdlib.Lexing.lexbuf -> Parser.token
val scan_fold_sexps : ?⁠buf:Stdlib.Buffer.t -> f:('a -> Type.t -> 'a) -> init:'a -> Stdlib.Lexing.lexbuf -> 'a
val scan_iter_sexps : ?⁠buf:Stdlib.Buffer.t -> f:(Type.t -> unit) -> Stdlib.Lexing.lexbuf -> unit
val scan_sexps_conv : ?⁠buf:Stdlib.Buffer.t -> f:(Type.t -> 'a) -> Stdlib.Lexing.lexbuf -> 'a list
val sexp_conversion_error_message : ?⁠containing_sexp:t -> ?⁠location:string -> ?⁠invalid_sexp:t -> unit -> exn:exn -> t
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
and ('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) Stdlib.result
val gen_input_sexp : (?⁠parse_pos:Parse_pos.t -> ?⁠len:int -> string -> (string, 'a) parse_result) -> ?⁠parse_pos:Parse_pos.t -> Stdlib.in_channel -> 'a
val input_sexp : ?⁠parse_pos:Parse_pos.t -> Stdlib.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 -> Stdlib.in_channel -> 'a list
val input_rev_sexps : ?⁠parse_pos:Parse_pos.t -> ?⁠buf:bytes -> Stdlib.in_channel -> Type.t list
val input_sexps : ?⁠parse_pos:Parse_pos.t -> ?⁠buf:bytes -> Stdlib.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) Stdlib.Bigarray.Array1.t -> int -> int -> string
val bstr_ws_buf : (char, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t
val of_bigstring : bigstring -> Type.t
val gen_load_rev_sexps : (?⁠parse_pos:'a -> ?⁠buf:'b -> Stdlib.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 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 = [
| `Not_found
| found
]
val search_physical : t -> contained:t -> [ `Found | `Not_found | `Pos of int * found ]
val subst_found : t -> subst:t -> [< `Found | `Pos of int * 'a ] as 'a -> t