Sexplib.Pre_sexp
module Sexplib = Sexplib0
module Conv = Sexplib.Sexp_conv
include module type of struct include Type end
Type of S-expressions
type bigstring =
(char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
include module type of struct include Sexplib.Sexp end with type t := t
exception 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.
exception 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.
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)
val default_indent : int ref
default_indent
reference to default indentation level for human-readable conversions.
Initialisation value: 2.
val pp_hum : Format.formatter -> t -> unit
pp_hum ppf sexp
outputs S-expression sexp
to formatter ppf
in human readable form.
val 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
.
val 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.
val pp : Format.formatter -> t -> unit
Same as pp_mach
.
val 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
.
val to_string_mach : t -> string
to_string_mach sexp
converts S-expression sexp
to a string in machine readable (i.e. most compact) form.
val to_string : t -> string
Same as to_string_mach
.
val of_float_style : [ `Underscores | `No_underscores ] ref
val of_int_style : [ `Underscores | `No_underscores ] ref
module Private = Sexplib.Sexp.Private
val t_sexp_grammar : Sexplib0.Sexp.t Sexplib0.Sexp_grammar.t
val with_new_buffer : out_channel -> (Buffer.t -> 'a) -> unit
val output_hum : out_channel -> Sexplib0__Sexp.t -> unit
val output_hum_indent : int -> out_channel -> Sexplib0__Sexp.t -> unit
val output_mach : out_channel -> Sexplib0__Sexp.t -> unit
val output : out_channel -> Sexplib0__Sexp.t -> unit
module Tmp_file : sig ... end
val save_of_output :
?perm:int ->
(out_channel -> 'a -> 'b) ->
string ->
'c ->
unit
val output_sexp_nl : (out_channel -> 'a -> 'b) -> out_channel -> 'c -> unit
val output_sexps_nl :
(out_channel -> 'a -> 'b) ->
out_channel ->
'c 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 -> 'b) ->
init:'c ->
Lexing.lexbuf ->
'd
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 ->
'b list
module Annot : sig ... end
module Parse_pos : sig ... end
module Cont_state = Parsexp.Old_parser_cont_state
and ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result
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 (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:'d ->
'e ->
'f
val feed_end_of_input :
this_parse:(pos:int -> len:int -> 'a -> ('b, 'c) parse_result) ->
ws_buf:'d ->
('e, Cont_state.t) result
val gen_input_sexp :
(?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, 'a) parse_result) ->
?parse_pos:Parse_pos.t ->
in_channel ->
'b
val input_sexp : ?parse_pos:Parse_pos.t -> 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 ->
in_channel ->
'b list
val input_rev_sexps :
?parse_pos:Parse_pos.t ->
?buf:bytes ->
in_channel ->
Type.t list
val input_sexps :
?parse_pos:Parse_pos.t ->
?buf:bytes ->
in_channel ->
Type.t list
val of_string_bigstring :
string ->
(?parse_pos:Parse_pos.t -> ?len:'a -> 'b -> ('c, 'd) parse_result) ->
'e ->
('f -> 'g) ->
('h -> int -> 'i -> string) ->
'j ->
'k
val of_string : string -> Type.t
val of_string_many : string -> Parsexp.Many.parsed_value
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 gen_load_rev_sexps :
(?parse_pos:'a -> ?buf:'b -> in_channel -> 'c) ->
?buf:'d ->
string ->
'e
val load_rev_sexps : ?buf:bytes -> string -> Type.t list
val load_sexps : ?buf:bytes -> string -> Type.t list
val gen_load_sexp :
(?parse_pos:Parse_pos.t -> ?len:int -> string -> (string, 'a) parse_result) ->
?strict:bool ->
?buf:bytes ->
string ->
'b
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 'b ]
val raise_conv_exn :
file:string ->
[< `Error of exn * Annotated.t | `Result of 'a ] ->
'b
val load_sexp_conv_exn :
?strict:bool ->
?buf:bytes ->
string ->
(Type.t -> 'a) ->
'b
val load_sexps_conv :
?buf:bytes ->
string ->
(Type.t -> 'a) ->
[> `Error of exn * Annotated.t | `Result of 'b ] list
val load_sexps_conv_exn : ?buf:bytes -> string -> (Type.t -> 'a) -> 'b list
val gen_of_string_conv :
('a -> Type.t) ->
('b -> Annotated.t) ->
'c ->
(Type.t -> 'd) ->
[> `Error of exn * Annotated.t | `Result of 'e ]
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 of_string_conv_exn : string -> (Type.t -> 'a) -> 'b
val of_string_many_conv_exn : string -> (Type.t -> 'a) -> 'b list
val unit : t
val is_unit : t -> bool