package sexplib

You can search for identifiers within the package.

in-package search v0.2.0

package sexplib

sexplib
- CHANGES
- LICENSE
- Library sexplib
  - Sexplib
    
    Conv
    
    Exn_converter
    
    Conv_error
    
    Exn_magic
    
    Lexer
    
    Parser
    
    Parser_with_layout
    
    Path
    
    Pre_sexp
    
    Sexplib
    
    Conv
    
    Private
    
    Tmp_file
    
    Annot
    
    Parse_pos
    
    Cont_state
    
    Parser_output
    
    T
    
    Impl
    
    State
    
    Read_only
    
    Stack
    
    Lexbuf_consumer
    
    Bare_sexp
    
    Impl
    
    State
    
    Read_only
    
    Stack
    
    Lexbuf_consumer
    
    Annotated_sexp
    
    Impl
    
    State
    
    Read_only
    
    Stack
    
    Lexbuf_consumer
    
    Make_parser
    
    String_single_sexp
    
    String_single_annot
    
    Bigstring_single_sexp
    
    Bigstring_single_annot
    
    Annotated
    
    Of_string_conv_exn
    
    Sexp
    
    Parse_pos
    
    Cont_state
    
    Annotated
    
    Of_string_conv_exn
    
    With_layout
    
    Forget
    
    Render
    
    Parser
    
    Lexer
    
    Sexp_grammar
    
    S
    
    Sexp_grammar_intf
    
    S
    
    Sexp_grammar
    
    S
    
    Sexp_intf
    
    S
    
    Parse_pos
    
    Cont_state
    
    Annotated
    
    Of_string_conv_exn
    
    With_layout
    
    Forget
    
    Render
    
    Parser
    
    Lexer
    
    Sexp_with_layout
    
    List
    
    Make
    
    Parsed
    
    Lexer
    
    Parser
    
    Render
    
    Rel_pos
    
    Abs_pos
    
    Forget
    
    Cps
    
    Src_pos
    
    Relative
    
    Absolute
    
    Std
    
    Hashtbl
    
    HashedType
    
    S
    
    Make
    
    SeededHashedType
    
    SeededS
    
    MakeSeeded
    
    Lazy
    
    Type
    
    Type_with_layout
    
    Make
    
    S
    
    Parsed
- Library sexplib.num
  - Sexplib_num
    
    Sexplib_num_conv
    
    Std
    
    Big_int
    
    Nat
    
    Ratio
    
    Num
- Library sexplib.unix
  - Sexplib_unix
    
    Sexplib_unix_conv
- Sources
  - sexplib
    
    conv.ml
    
    conv_error.ml
    
    exn_magic.ml
    
    lexer.ml
    
    parser.ml
    
    parser_with_layout.ml
    
    path.ml
    
    pre_sexp.ml
    
    sexp.ml
    
    sexp_grammar.ml
    
    sexp_grammar_intf.ml
    
    sexp_intf.ml
    
    sexp_with_layout.ml
    
    sexplib.ml
    
    src_pos.ml
    
    std.ml
    
    type.ml
    
    type_with_layout.ml
  - sexplib.num
    
    sexplib_num.ml
    
    sexplib_num_conv.ml
    
    std.ml
  - sexplib.unix
    
    sexplib_unix.ml
    
    sexplib_unix_conv.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Sexplib.Pre_sexp`Source

Sourcemodule Sexplib = Sexplib0

Sourcemodule Conv = Sexplib.Sexp_conv

include module type of struct include Type end

Sourcetype t = Sexplib0.Sexp.t =

| Atom of string
| List of t list

Type of S-expressions

Source

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

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

Sourcemodule Private = Sexplib.Sexp.Private

include module type of struct include Private end

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

Source

val 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 t_sexp_grammar : Sexplib0.Sexp.t Sexplib0.Sexp_grammar.t

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

Source

val 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

Source

val 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

Source

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

Source

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

Source

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

Source

val 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

Sourcemodule Cont_state = Parsexp.Old_parser_cont_state

Sourcetype ('a, 't) parse_result =

| Done of 't * Parse_pos.t
| 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 = {

parse_pos : Parse_pos.t;

}

Sourcetype parse_error = {

err_msg : string;
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

Source

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

Source

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

Sourcemodule String_single_annot : sig ... end

Source

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

Sourcemodule Bigstring_single_sexp : sig ... end

Source

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

Sourcemodule Bigstring_single_annot : sig ... end

Source

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

Source

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

Source

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

Source

val 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

Source

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 ->
  'a list

Source

val input_rev_sexps : 
  ?parse_pos:Parse_pos.t ->
  ?buf:bytes ->
  in_channel ->
  Type.t list

Source

val input_sexps : 
  ?parse_pos:Parse_pos.t ->
  ?buf:bytes ->
  in_channel ->
  Type.t list

Source

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

Sourceval of_string : string -> Type.t

Sourceval of_string_many : string -> Parsexp.Many.parsed_value

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

Source

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

Sourceval of_bigstring : bigstring -> Type.t

Source

val 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

Source

val 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

Source

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

Source

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

Source

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

Source

val 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

Source

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

Source

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

Source

val 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 of_string_many_conv_exn : string -> (Type.t -> 'a) -> 'a list

Sourceval unit : t

Sourceval is_unit : t -> bool

Sourceval sexp_of_t : t -> t

Sourceval t_of_sexp : t -> t

Sourcetype found = [

| `Found
| `Pos of int * found

]

Sourcetype search_result = [

| `Not_found
| found

]

Source

val 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

package sexplib

Module Sexplib.Pre_sexpSource

Helpers

Defaults

Pretty printing of S-expressions

Conversion to strings

Styles

Module `Sexplib.Pre_sexp`Source