Module Core_kernel__.Sexp

Code for managing s-expressions.

type t = Base.Sexp.t =
| Atom of Core_kernel__.Import.string
| List of t Core_kernel__.Import.list
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Core_kernel__.Import.int ‑> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_shape_t : Bin_prot.Shape.t
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Sexplib.Sexp.t
module O : sig ... end
include Core_kernel.Comparable.S with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable_intf.S
include Base.Comparable_intf.Polymorphic_compare
include Base.Comparisons.Infix
type t
val (>=) : t ‑> t ‑> bool
val (<=) : t ‑> t ‑> bool
val (=) : t ‑> t ‑> bool
val (>) : t ‑> t ‑> bool
val (<) : t ‑> t ‑> bool
val (<>) : t ‑> t ‑> bool
val equal : t ‑> t ‑> bool
val compare : t ‑> t ‑> int

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t ‑> t ‑> t
val max : t ‑> t ‑> t
val ascending : t ‑> t ‑> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~cmp:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t ‑> t ‑> int
val between : t ‑> low:t ‑> high:t ‑> bool
val clamp_exn : t ‑> min:t ‑> max:t ‑> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t
include Base.Comparator.S with type t := t
type t
type comparator_witness
include Base.Comparable_intf.Validate with type t := t
type t
val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check
include Core_kernel__.Import.Stringable.S with type t := t
type t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel.Quickcheckable.S with type t := t
type 'a gen
type 'a obs
type 'a shr
type t
val gen : t gen
val obs : t obs
val shrinker : t shr
include module type of sig ... end with type t := t
type t = Sexplib.Type.t =
| Atom of string
| List of t list
type bigstring = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
val compare : t ‑> t ‑> int
val default_indent : int Pervasives.ref
val size : t ‑> int * int
val scan_sexp : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t
val scan_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t list
val scan_rev_sexps : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t list
val scan_sexp_opt : ?⁠buf:Buffer.t ‑> Lexing.lexbuf ‑> t option
val scan_iter_sexps : ?⁠buf:Buffer.t ‑> f:(t ‑> unit) ‑> Lexing.lexbuf ‑> unit
val scan_fold_sexps : ?⁠buf:Buffer.t ‑> f:('a ‑> t ‑> 'a) ‑> init:'a ‑> Lexing.lexbuf ‑> 'a
val scan_sexps_conv : ?⁠buf:Buffer.t ‑> f:(t ‑> 'a) ‑> Lexing.lexbuf ‑> 'a list
type ('a, 't) parse_result = ('a, 't) Sexplib.Pre_sexp.parse_result =
| Done of 't * Parse_pos.t
| Cont of Cont_state.t * ('a, 't) parse_fun
type ('a, 't) parse_fun = pos:int ‑> len:int ‑> 'a ‑> ('a, 't) parse_result
type 't parse_state = private 't Sexplib.Pre_sexp.parse_state = {
parse_pos : Parse_pos.t;
mutable pstack : 't;
pbuf : Buffer.t;
}
type parse_error = Sexplib.Pre_sexp.parse_error = {
location : string;
err_msg : string;
parse_state : [ `Annot of Annotated.stack parse_state | `Sexp of t list list parse_state ];
}
exception Parse_error of parse_error
val parse : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> string ‑> (string, t) parse_result
val parse_bigstring : ?⁠parse_pos:Parse_pos.t ‑> ?⁠len:int ‑> bigstring ‑> (bigstring, t) parse_result
val input_sexp : ?⁠parse_pos:Parse_pos.t ‑> Pervasives.in_channel ‑> t
val input_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> t list
val input_rev_sexps : ?⁠parse_pos:Parse_pos.t ‑> ?⁠buf:bytes ‑> Pervasives.in_channel ‑> t list
val load_sexp : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> t
val load_sexps : ?⁠buf:bytes ‑> string ‑> t list
val load_rev_sexps : ?⁠buf:bytes ‑> string ‑> t list
val load_sexp_conv : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a Annotated.conv
val load_sexp_conv_exn : ?⁠strict:bool ‑> ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a
val load_sexps_conv : ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a Annotated.conv list
val load_sexps_conv_exn : ?⁠buf:bytes ‑> string ‑> (t ‑> 'a) ‑> 'a list
val output_hum : Pervasives.out_channel ‑> t ‑> unit
val output_hum_indent : int ‑> Pervasives.out_channel ‑> t ‑> unit
val output_mach : Pervasives.out_channel ‑> t ‑> unit
val output : Pervasives.out_channel ‑> t ‑> unit
val save_hum : ?⁠perm:int ‑> string ‑> t ‑> unit
val save_mach : ?⁠perm:int ‑> string ‑> t ‑> unit
val save : ?⁠perm:int ‑> string ‑> t ‑> unit
val save_sexps_hum : ?⁠perm:int ‑> string ‑> t list ‑> unit
val save_sexps_mach : ?⁠perm:int ‑> string ‑> t list ‑> unit
val save_sexps : ?⁠perm:int ‑> string ‑> t list ‑> unit
val pp_hum : Format.formatter ‑> t ‑> unit
val pp_hum_indent : int ‑> Format.formatter ‑> t ‑> unit
val pp_mach : Format.formatter ‑> t ‑> unit
val pp : Format.formatter ‑> t ‑> unit
val of_string : string ‑> t
val of_string_conv : string ‑> (t ‑> 'a) ‑> 'a Annotated.conv
val of_string_conv_exn : string ‑> (t ‑> 'a) ‑> 'a
val of_bigstring : bigstring ‑> t
val of_bigstring_conv : bigstring ‑> (t ‑> 'a) ‑> 'a Annotated.conv
val of_bigstring_conv_exn : bigstring ‑> (t ‑> 'a) ‑> 'a
val to_string_hum : ?⁠indent:int ‑> t ‑> string
val to_string_mach : t ‑> string
val to_string : t ‑> string
val to_buffer_hum : buf:Buffer.t ‑> ?⁠indent:int ‑> t ‑> unit
val to_buffer_mach : buf:Buffer.t ‑> t ‑> unit
val to_buffer : buf:Buffer.t ‑> t ‑> unit
val to_buffer_gen : buf:'buffer ‑> add_char:('buffer ‑> char ‑> unit) ‑> add_string:('buffer ‑> string ‑> unit) ‑> t ‑> unit
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 = [
| `Found
| `Not_found
| `Pos of int * found
]
val search_physical : t ‑> contained:t ‑> search_result
val subst_found : t ‑> subst:t ‑> found ‑> t
exception Of_sexp_error of Core_kernel__.Import.exn * t
val of_float_style : [ `Underscores | `No_underscores ] Core_kernel__.Import.ref
val of_int_style : [ `Underscores | `No_underscores ] Core_kernel__.Import.ref
type 'a no_raise = 'a

no_raise is the identity, but by using 'a no_raise in a sexpable type, the resulting use sexp_of_no_raise protects the conversion of 'a to a sexp so that if it fails, one gets a sexp with an error message about the failure, rather than an exception being raised.

WARNING: The resulting no_raise_of_sexp can still raise.

include sig ... end
val bin_read_no_raise : 'a Bin_prot.Read.reader ‑> 'a no_raise Bin_prot.Read.reader
val __bin_read_no_raise__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a no_raise) Bin_prot.Read.reader
val bin_size_no_raise : 'a Bin_prot.Size.sizer ‑> 'a no_raise Bin_prot.Size.sizer
val bin_write_no_raise : 'a Bin_prot.Write.writer ‑> 'a no_raise Bin_prot.Write.writer
val bin_shape_no_raise : Bin_prot.Shape.t ‑> Bin_prot.Shape.t
val no_raise_of_sexp : (Sexplib.Sexp.t ‑> 'a) ‑> Sexplib.Sexp.t ‑> 'a no_raise
val sexp_of_no_raise : ('a ‑> Sexplib.Sexp.t) ‑> 'a no_raise ‑> Sexplib.Sexp.t
module Sexp_maybe : sig ... end

If sexp_of_t fails, it returns Error rather than raising. You can convert values of this type to and from sexp in processes that can or cannot parse the underlying sexp in any combination and still recover the original value. Also, the Error case contains a human-readable description of the error.

module With_text : sig ... end

A With_text.t is a value paired with the full textual representation of its sexp. This is useful for dealing with the case where you want to keep track of a value along with the format of the s-expression it was generated from, which allows you to maintain formatting details, comments, etc.

val of_sexp_allow_extra_fields : (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a

of_sexp_allow_extra_fields of_sexp sexp uses of_sexp to convert sexp to a value, but will not fail if there are any extra fields in a record (even deeply nested records).

The implementation uses global state, so it is not thread safe.