sexplib v0.10.0 · OCaml Package

module Sexplib = Sexplib0

module Conv = Sexplib.Sexp_conv

include module type of struct include Type end

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 struct include Sexplib.Sexp end with type t := t

val equal : t -> t -> bool

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.

Helpers

val 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

val default_indent : int Pervasives.ref

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

Initialisation value: 2.

Pretty printing of S-expressions

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.

Conversion to strings

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.

parameter indent
default = !default_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.

Styles

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

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

module Private = Sexplib.Sexp.Private

include module type of struct include Private end

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 compare_list : ('a -> 'b -> int) -> 'a list -> 'b list -> int

val compare : t -> t -> int

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

and ('a, 't) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result

type 't parse_state = {

parse_pos : Parse_pos.t;
mutable pstack : 't;
pbuf : Buffer.t;

}

type parse_error = {

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

}

exception Parse_error of parse_error

val bump_text_line : 'a parse_state -> unit

val bump_text_pos : 'a parse_state -> unit

val bump_pos_cont : 
  'a parse_state ->
  'b ->
  max_pos:'c ->
  pos:int ->
  ('a parse_state -> 'b -> max_pos:'c -> pos:int -> 'd) ->
  'd

val bump_line_cont : 
  'a parse_state ->
  'b ->
  max_pos:'c ->
  pos:int ->
  ('a parse_state -> 'b -> max_pos:'c -> pos:int -> 'd) ->
  'd

val add_bump : 
  ('a parse_state -> 'b) ->
  'a parse_state ->
  'c ->
  max_pos:'d ->
  pos:int ->
  char ->
  ('a parse_state -> 'c -> max_pos:'d -> pos:int -> 'e) ->
  'e

val add_bump_pos : 
  'a parse_state ->
  'b ->
  max_pos:'c ->
  pos:int ->
  char ->
  ('a parse_state -> 'b -> max_pos:'c -> pos:int -> 'd) ->
  'd

val add_bump_line : 
  'a parse_state ->
  'b ->
  max_pos:'c ->
  pos:int ->
  char ->
  ('a parse_state -> 'b -> max_pos:'c -> pos:int -> 'd) ->
  'd

val set_parse_pos : Parse_pos.t -> int -> unit

val mk_parse_pos : 'a parse_state -> int -> Parse_pos.t

val raise_parse_error : 
  [ `Annot of Annot.stack parse_state | `Sexp of t list list parse_state ] ->
  string ->
  int ->
  string ->
  'a

val raise_unexpected_char : 
  [ `Annot of Annot.stack parse_state | `Sexp of t list list parse_state ] ->
  string ->
  int ->
  char ->
  'a

val mk_cont_parser : 
  (pos:int -> len:int -> 'a -> 'b) ->
  'c ->
  'a ->
  max_pos:int ->
  pos:int ->
  'b

module Safe_empty_parse : sig ... end

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

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

val get_glob_ofs : Parse_pos.t -> int -> int

val mk_annot_pos : Parse_pos.t -> int -> Annot.pos

val mk_annot_pos1 : Parse_pos.t -> int -> Annot.pos

val add_annot_pos : Annot.stack parse_state -> int -> unit

val add_annot_pos1 : Annot.stack parse_state -> int -> unit

val get_annot_range : Annot.stack parse_state -> int -> Annot.range

val mk_annot_atom : Annot.stack parse_state -> string -> int -> Annot.t

val mk_annot_list : Annot.stack parse_state -> Annot.t list -> int -> Annot.t

val init_annot_pstate : unit -> Annot.stack

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

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

val bump_found_atom : 
  (Annot.stack parse_state -> 'a) ->
  Annot.stack parse_state ->
  'b ->
  max_pos:'c ->
  pos:int ->
  (Annot.stack parse_state ->
    'b ->
    max_pos:'c ->
    pos:int ->
    ('d, Annot.t) parse_result) ->
  ('d, Annot.t) parse_result

val check_str_bounds : string -> pos:int -> len:int -> bigstring -> int

val mk_cont_state : 
  string ->
  ('a -> bigstring -> max_pos:int -> pos:int -> (bigstring, 'b) parse_result) ->
  'a ->
  cont_state:Cont_state.t ->
  (bigstring, 'b) parse_result

val mk_cont : 
  string ->
  eof_safe:Safe_empty_parse.t ->
  (Annot.stack parse_state ->
    bigstring ->
    max_pos:int ->
    pos:int ->
    (bigstring, 'a) parse_result) ->
  Annot.stack parse_state ->
  (bigstring, 'a) parse_result

val parse_nl : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_comment : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val maybe_parse_comment : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val maybe_parse_close_comment : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_sexp_comment : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_block_comment : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_atom : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val maybe_parse_bad_atom_pipe : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val maybe_parse_bad_atom_hash : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val reg_parse_quoted : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_quoted : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_escaped : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_skip_ws : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_skip_ws_nl : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  (bigstring, Annot.t) parse_result

val parse_dec : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  count:int ->
  d:int ->
  (bigstring, Annot.t) parse_result

val parse_hex : 
  Annot.stack parse_state ->
  bigstring ->
  max_pos:int ->
  pos:int ->
  count:int ->
  d:int ->
  (bigstring, Annot.t) parse_result

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 -> 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 ->
  t list

val input_sexps : 
  ?parse_pos:Parse_pos.t ->
  ?buf:bytes ->
  Pervasives.in_channel ->
  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 -> 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 -> 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 -> t list

val load_sexps : ?buf:bytes -> string -> 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 -> 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