Up

Module Sexp

Signature

include Core.Std.Sexp
type t = Sexplib.Sexp.t =
| Atom of string
| List of t list
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (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
module O : sig .. end
include Core_kernel.Interfaces.Comparable with type t := t
include Comparable_intf.S_common
include Comparable_intf.Polymorphic_compare
include Polymorphic_compare_intf.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
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 Or_error.t
include Comparator.S with type t := t
type t
type comparator_witness
include Comparable_intf.Validate with type t := t
type t
val validate_lbound : min:t Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Maybe_bound.t -> t Validate.check
val validate_bound : min:t Maybe_bound.t -> max:t Maybe_bound.t -> t Validate.check
include Core_kernel.Interfaces.Stringable with type t := t
type t
val of_string : string -> t
val to_string : t -> string
include Core_kernel.Interfaces.Quickcheckable 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
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 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 = 't Sexplib.Pre_sexp.parse_state = private {
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:string -> Pervasives.in_channel -> t list
val input_rev_sexps : ?parse_pos:Parse_pos.t -> ?buf:string -> Pervasives.in_channel -> t list
val load_sexp : ?strict:bool -> ?buf:string -> string -> t
val load_sexps : ?buf:string -> string -> t list
val load_rev_sexps : ?buf:string -> string -> t list
val load_sexp_conv : ?strict:bool -> ?buf:string -> string -> (t -> 'a) -> 'a Annotated.conv
val load_sexp_conv_exn : ?strict:bool -> ?buf:string -> string -> (t -> 'a) -> 'a
val load_sexps_conv : ?buf:string -> string -> (t -> 'a) -> 'a Annotated.conv list
val load_sexps_conv_exn : ?buf:string -> 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 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 exn * t
val of_int_style : [
| `Underscores
| `No_underscores
] Pervasives.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 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
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 -> (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
module Sexp_maybe : sig .. end
If sexp_of_t fails, it returns Error rather than raising.
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 : (Sexplib.Sexp.t -> 'a) -> Sexplib.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.

include Extended_sexp
val is_atom : Core.Std.Sexp.t -> bool
val is_list : Core.Std.Sexp.t -> bool

Constructors

val atom : string -> Core.Std.Sexp.t
val list : Core.Std.Sexp.t list -> Core.Std.Sexp.t
val to_string_hum' : Core.Std.Sexp.t -> string

The ocaml pretty printer (used by sexplib) is a speed daemon but is, sadly enough, produces wrong output (e.g it overflows in places where this could have avoided). This uses a printer from wadler's a prettier printer to output strings suited to human consumption.

val format : Core.Std.Sexp.t -> Pp.t
val pp_hum' : Format.formatter -> Core.Std.Sexp.t -> unit

A more readable but less compact pretty printer than the one bundled by sexplib. This is going through a test period at which point it might make it in sexplib. It uses ocaml's pretty-printing library so it is both fast and broken.

val comment : string -> string

Takes a string and returns the same string but commented according to sexp's syntax

module Diff : sig .. end
val print_diff : ?oc:Core.Std.out_channel -> original:Core.Std.Sexp.t -> updated:Core.Std.Sexp.t -> unit -> unit
val summarize : Core.Std.Sexp.t -> sub_sexp:Core.Std.Sexp.t -> size:[
| `depth of int
| `string of int
] -> Core.Std.Sexp.t

Returns a smaller sexp by replacing sections with "...". Will try to show parts of the sexp "near" sub_sexp.

Limiting size to length a string length is less efficient than a certain depth. The meaning of a given depth is arbitrary except that more depth gives you a bigger sexp. Try 100 or so.

Transforming sexp parsers

module Records_table : sig .. end
module Make_explicit_sexp_option (T : sig .. end) : sig .. end
val load_sexp_conv_exn_sample : ?strict:bool -> ?buf:string -> ?on_non_existence:[
| `Exit
| `Raise
] -> ?name:string -> string -> sexp_of_t:('a -> Core.Std.Sexp.t) -> t_of_sexp:(Core.Std.Sexp.t -> 'a) -> sample:'a -> 'a
module Comprehension : sig .. end