Module Sexplib.Pre_sexpSource

Sourcemodule Sexplib = Sexplib0
include module type of struct include Type end
Sourcetype t = Sexplib0.Sexp.t =
  1. | Atom of string
  2. | List of t list

Type of S-expressions

include module type of struct include Sexplib.Sexp end with type t := t
Sourceval t_sexp_grammar : Sexplib0__.Raw_grammar.t
Sourceval equal : t -> t -> bool
Sourceval compare : t -> t -> int
Sourceexception Not_found_s of t

Not_found_s is used by functions that historically raised Not_found, to allow them to raise an exception that contains an informative error message (as a sexp), while still having an exception that can be distinguished from other exceptions.

Sourceexception Of_sexp_error of exn * t

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

Helpers

Sourceval message : string -> (string * t) list -> t

Helper to build nice s-expressions for error messages. It imitates the behavior of [%message ...] from the ppx_sexp_message rewriter.

message name key_values produces a s-expression list starting with atom name and followed by list of size 2 of the form (key value). When the key is the empty string, value is used directly instead as for [%message].

For instance the following code:

  Sexp.message "error"
    [ "x", sexp_of_int 42
    ; "" , sexp_of_exn Exit
    ]

produces the s-expression:

  (error (x 42) Exit)

Defaults

Sourceval default_indent : int ref

default_indent reference to default indentation level for human-readable conversions.

Initialisation value: 2.

Pretty printing of S-expressions

Sourceval pp_hum : Format.formatter -> t -> unit

pp_hum ppf sexp outputs S-expression sexp to formatter ppf in human readable form.

Sourceval pp_hum_indent : int -> Format.formatter -> t -> unit

pp_hum_indent n ppf sexp outputs S-expression sexp to formatter ppf in human readable form and indentation level n.

Sourceval pp_mach : Format.formatter -> t -> unit

pp_mach ppf sexp outputs S-expression sexp to formatter ppf in machine readable (i.e. most compact) form.

Sourceval pp : Format.formatter -> t -> unit

Same as pp_mach.

Conversion to strings

Sourceval to_string_hum : ?indent:int -> t -> string

to_string_hum ?indent sexp converts S-expression sexp to a string in human readable form with indentation level indent.

  • parameter indent

    default = !default_indent

Sourceval to_string_mach : t -> string

to_string_mach sexp converts S-expression sexp to a string in machine readable (i.e. most compact) form.

Sourceval to_string : t -> string

Same as to_string_mach.

Styles

Sourceval of_float_style : [ `Underscores | `No_underscores ] ref
Sourceval of_int_style : [ `Underscores | `No_underscores ] ref
include module type of struct include Private end
Sourcemodule Raw_grammar = Private.Raw_grammar
Sourceval size : Sexplib0.Sexp.t -> int * int
Sourceval buffer : unit -> Buffer.t
Sourceval to_buffer : buf:Buffer.t -> Sexplib0.Sexp.t -> unit
Sourceval to_buffer_hum : buf:Buffer.t -> ?indent:int -> Sexplib0.Sexp.t -> unit
Sourceval to_buffer_mach : buf:Buffer.t -> Sexplib0.Sexp.t -> unit
Sourceval to_buffer_gen : buf:'buffer -> add_char:('buffer -> char -> unit) -> add_string:('buffer -> string -> unit) -> Sexplib0.Sexp.t -> unit
Sourceval mach_maybe_esc_str : string -> string
Sourceval must_escape : string -> bool
Sourceval esc_str : string -> string
Sourceval with_new_buffer : out_channel -> (Buffer.t -> 'a) -> unit
Sourceval output_hum : out_channel -> Sexplib0__Sexp.t -> unit
Sourceval output_hum_indent : int -> out_channel -> Sexplib0__Sexp.t -> unit
Sourceval output_mach : out_channel -> Sexplib0__Sexp.t -> unit
Sourceval output : out_channel -> Sexplib0__Sexp.t -> unit
Sourcemodule Tmp_file : sig ... end
Sourceval save_of_output : ?perm:int -> (out_channel -> 'a -> 'b) -> string -> 'a -> unit
Sourceval output_sexp_nl : (out_channel -> 'a -> 'b) -> out_channel -> 'a -> unit
Sourceval save_hum : ?perm:int -> string -> Sexplib0__Sexp.t -> unit
Sourceval save_mach : ?perm:int -> string -> Sexplib0__Sexp.t -> unit
Sourceval save : ?perm:int -> string -> Sexplib0__Sexp.t -> unit
Sourceval output_sexps_nl : (out_channel -> 'a -> 'b) -> out_channel -> 'a list -> unit
Sourceval save_sexps_hum : ?perm:int -> string -> Sexplib0__Sexp.t list -> unit
Sourceval save_sexps_mach : ?perm:int -> string -> Sexplib0__Sexp.t list -> unit
Sourceval save_sexps : ?perm:int -> string -> Sexplib0__Sexp.t list -> unit
Sourceval scan_sexp : ?buf:Buffer.t -> Lexing.lexbuf -> Type.t
Sourceval scan_sexp_opt : ?buf:Buffer.t -> Lexing.lexbuf -> Type.t option
Sourceval scan_sexps : ?buf:Buffer.t -> Lexing.lexbuf -> Type.t list
Sourceval scan_rev_sexps : ?buf:Buffer.t -> Lexing.lexbuf -> Type.t list
Sourceval get_main_buf : Buffer.t option -> Lexing.lexbuf -> Parser.token
Sourceval scan_fold_sexps : ?buf:Buffer.t -> f:('a -> Type.t -> 'a) -> init:'a -> Lexing.lexbuf -> 'a
Sourceval scan_iter_sexps : ?buf:Buffer.t -> f:(Type.t -> unit) -> Lexing.lexbuf -> unit
Sourceval scan_sexps_conv : ?buf:Buffer.t -> f:(Type.t -> 'a) -> Lexing.lexbuf -> 'a list
Sourceval sexp_conversion_error_message : ?containing_sexp:t -> ?location:string -> ?invalid_sexp:t -> unit -> exn:exn -> t
Sourcemodule Annot : sig ... end
Sourcemodule Parse_pos : sig ... end
Sourcetype ('a, 't) parse_result =
  1. | Done of 't * Parse_pos.t
  2. | Cont of Cont_state.t * ('a, 't) parse_fun
Sourceand ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result
Sourcetype 't parse_state = {
  1. parse_pos : Parse_pos.t;
}
Sourcetype parse_error = {
  1. err_msg : string;
  2. parse_state : [ `Sexp of t list list parse_state | `Annot of Annot.stack parse_state ];
}
Sourceexception Parse_error of parse_error
Sourcemodule Parser_output : sig ... end
Sourcemodule Make_parser (T : sig ... end) : sig ... end
Sourcemodule String_single_sexp : sig ... end
Sourceval parse_str : ?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, Type.t) parse_result
Sourceval parse : ?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, Type.t) parse_result
Sourcemodule String_single_annot : sig ... end
Sourceval parse_str_annot : ?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, Annot.t) parse_result
Sourcemodule Bigstring_single_sexp : sig ... end
Sourceval parse_bigstring : ?parse_pos:Parse_pos.t -> ?len:int -> bigstring -> (bigstring, Type.t) parse_result
Sourcemodule Bigstring_single_annot : sig ... end
Sourceval parse_bigstring_annot : ?parse_pos:Parse_pos.t -> ?len:int -> bigstring -> (bigstring, Annot.t) parse_result
Sourceval mk_this_parse : ?parse_pos:Parse_pos.t -> (?parse_pos:Parse_pos.t -> ?len:'a -> 'b -> 'c) -> pos:int -> len:'a -> 'b -> 'c
Sourceval feed_end_of_input : this_parse:(pos:int -> len:int -> 'a -> ('b, 'c) parse_result) -> ws_buf:'a -> ('c, Cont_state.t) result
Sourceval gen_input_sexp : (?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, 'a) parse_result) -> ?parse_pos:Parse_pos.t -> in_channel -> 'a
Sourceval input_sexp : ?parse_pos:Parse_pos.t -> in_channel -> Type.t
Sourceval 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 -> in_channel -> 'a list
Sourceval input_rev_sexps : ?parse_pos:Parse_pos.t -> ?buf:bytes -> in_channel -> Type.t list
Sourceval input_sexps : ?parse_pos:Parse_pos.t -> ?buf:bytes -> in_channel -> Type.t list
Sourceval 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
Sourceval of_string : string -> Type.t
Sourceval get_bstr_sub_str : (char, 'a, 'b) Bigarray.Array1.t -> int -> int -> string
Sourceval of_bigstring : bigstring -> Type.t
Sourceval gen_load_rev_sexps : (?parse_pos:'a -> ?buf:'b -> in_channel -> 'c) -> ?buf:'b -> string -> 'c
Sourceval load_rev_sexps : ?buf:bytes -> string -> Type.t list
Sourceval load_sexps : ?buf:bytes -> string -> Type.t list
Sourceval gen_load_sexp_loc : string
Sourceval gen_load_sexp : (?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, 'a) parse_result) -> ?strict:bool -> ?buf:bytes -> string -> 'a
Sourceval load_sexp : ?strict:bool -> ?buf:bytes -> string -> Type.t
Sourcemodule Annotated : sig ... end
Sourceval load_sexp_conv : ?strict:bool -> ?buf:bytes -> string -> (Type.t -> 'a) -> [> `Error of exn * Annotated.t | `Result of 'a ]
Sourceval raise_conv_exn : file:string -> [< `Error of exn * Annotated.t | `Result of 'a ] -> 'a
Sourceval load_sexp_conv_exn : ?strict:bool -> ?buf:bytes -> string -> (Type.t -> 'a) -> 'a
Sourceval load_sexps_conv : ?buf:bytes -> string -> (Type.t -> 'a) -> [> `Error of exn * Annotated.t | `Result of 'a ] list
Sourceval load_sexps_conv_exn : ?buf:bytes -> string -> (Type.t -> 'a) -> 'a list
Sourceval gen_of_string_conv : ('a -> Type.t) -> ('a -> Annotated.t) -> 'a -> (Type.t -> 'b) -> [> `Error of exn * Annotated.t | `Result of 'b ]
Sourceval of_string_conv : string -> (Type.t -> 'a) -> [> `Error of exn * Annotated.t | `Result of 'a ]
Sourceval of_bigstring_conv : bigstring -> (Type.t -> 'a) -> [> `Error of exn * Annotated.t | `Result of 'a ]
Sourcemodule Of_string_conv_exn : sig ... end
Sourceval gen_of_string_conv_exn : ('a -> Type.t) -> 'a -> (Type.t -> 'b) -> 'b
Sourceval of_string_conv_exn : string -> (Type.t -> 'a) -> 'a
Sourceval of_bigstring_conv_exn : bigstring -> (Type.t -> 'a) -> 'a
Sourceval unit : t
Sourceval is_unit : t -> bool
Sourceval sexp_of_t : t -> t
Sourceval t_of_sexp : t -> t
Sourcetype found = [
  1. | `Found
  2. | `Pos of int * found
]
Sourcetype search_result = [
  1. | `Not_found
  2. | found
]
Sourceval search_physical : t -> contained:t -> [ `Found | `Not_found | `Pos of int * found ]
Sourceval subst_found : t -> subst:t -> ([< `Found | `Pos of int * 'a ] as 'a) -> t