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 Bin_prot.Binable.S with type t := t
type t
include Bin_prot.Binable.S_only_functions with type t := t
type t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Ppx_sexp_conv_lib.Sexpable.S with type t := t
type t
val t_of_sexp : Sexplib0.Sexp.t -> t
val sexp_of_t : t -> Sexplib0.Sexp.t
module O : sig ... end
include Comparable.S with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.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 ~compare: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

between t ~low ~high means low <= t <= high

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
val comparator : (t, comparator_witness) Base.Comparator.comparator
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
module Map : Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness
module Set : Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness
include Core_kernel__.Import.Stringable.S with type t := t
type t
val of_string : string -> t
val to_string : t -> string
include Quickcheckable.S with type t := t
type t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
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, Stdlib.Bigarray.int8_unsigned_elt, Stdlib.Bigarray.c_layout) Stdlib.Bigarray.Array1.t
val compare : t -> t -> int
val equal : t -> t -> bool
val default_indent : int Stdlib.ref
val size : t -> int * int
val scan_sexp : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> t
val scan_sexps : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> t list
val scan_rev_sexps : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> t list
val scan_sexp_opt : ?⁠buf:Stdlib.Buffer.t -> Stdlib.Lexing.lexbuf -> t option
val scan_iter_sexps : ?⁠buf:Stdlib.Buffer.t -> f:(t -> unit) -> Stdlib.Lexing.lexbuf -> unit
val scan_fold_sexps : ?⁠buf:Stdlib.Buffer.t -> f:('a -> t -> 'a) -> init:'a -> Stdlib.Lexing.lexbuf -> 'a
val scan_sexps_conv : ?⁠buf:Stdlib.Buffer.t -> f:(t -> 'a) -> Stdlib.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
and ('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;
}
type parse_error = Sexplib.Pre_sexp.parse_error = {
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 -> Stdlib.in_channel -> t
val input_sexps : ?⁠parse_pos:Parse_pos.t -> ?⁠buf:bytes -> Stdlib.in_channel -> t list
val input_rev_sexps : ?⁠parse_pos:Parse_pos.t -> ?⁠buf:bytes -> Stdlib.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 : Stdlib.out_channel -> t -> unit
val output_hum_indent : int -> Stdlib.out_channel -> t -> unit
val output_mach : Stdlib.out_channel -> t -> unit
val output : Stdlib.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 : Stdlib.Format.formatter -> t -> unit
val pp_hum_indent : int -> Stdlib.Format.formatter -> t -> unit
val pp_mach : Stdlib.Format.formatter -> t -> unit
val pp : Stdlib.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:Stdlib.Buffer.t -> ?⁠indent:int -> t -> unit
val to_buffer_mach : buf:Stdlib.Buffer.t -> t -> unit
val to_buffer : buf:Stdlib.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.

val bin_shape_no_raise : Bin_prot.Shape.t -> Bin_prot.Shape.t
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_writer_no_raise : 'a Bin_prot.Type_class.writer -> 'a no_raise Bin_prot.Type_class.writer
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_reader_no_raise : 'a Bin_prot.Type_class.reader -> 'a no_raise Bin_prot.Type_class.reader
val bin_no_raise : 'a Bin_prot.Type_class.t -> 'a no_raise Bin_prot.Type_class.t
val sexp_of_no_raise : ('a -> Ppx_sexp_conv_lib.Sexp.t) -> 'a no_raise -> Ppx_sexp_conv_lib.Sexp.t
val no_raise_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'a) -> Ppx_sexp_conv_lib.Sexp.t -> 'a no_raise
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_recursively : (Base.Sexp.t -> 'a) -> Base.Sexp.t -> 'a

of_sexp_allow_extra_fields_recursively 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.

module Stable : sig ... end