package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type

Code for managing s-expressions.

type t = Base.Sexp.t =
  1. | Atom of Base.String.t
  2. | List of t Base.List.t
include Bin_prot.Binable.S with type t := 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
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
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_compare_lib.Comparable.S_local with type t := t
val compare__local : t Base__Ppx_compare_lib.compare__local
include Ppx_compare_lib.Equal.S with type t := t
include Ppx_compare_lib.Equal.S_local with type t := t
val equal__local : t Base__Ppx_compare_lib.equal__local
val globalize : t -> t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
include Sexplib0.Sexpable.S with type t := t
module O : sig ... end
include Comparable.S with type t := t
include Base.Comparable.S with type t := 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 min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
type comparator_witness
val comparator : (t, comparator_witness) Base__Comparator.comparator
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
module Replace_polymorphic_compare : sig ... end
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 Quickcheckable.S with type t := 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 struct include Sexplib.Sexp end with type t := t
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
module Parse_pos : sig ... end
module Cont_state : sig ... end
type (!'a, !'t) parse_result = ('a, 't) Sexplib.Pre_sexp.parse_result =
  1. | Done of 't * Parse_pos.t
  2. | Cont of Cont_state.t * ('a, 't) parse_fun
and (!'a, !'t) parse_fun = pos:int -> len:int -> 'a -> ('a, 't) parse_result
module Annotated : sig ... end
type !'t parse_state = private 't Sexplib.Pre_sexp.parse_state = {
  1. parse_pos : Parse_pos.t;
}
type parse_error = Sexplib.Pre_sexp.parse_error = {
  1. err_msg : string;
  2. 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
module Of_string_conv_exn : sig ... end
val of_string : string -> t
val of_string_many : string -> t list
val of_string_conv : string -> (t -> 'a) -> 'a Annotated.conv
val of_string_many_conv_exn : string -> (t -> 'a) -> 'a list
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
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
type found = [
  1. | `Found
  2. | `Pos of int * found
]
type search_result = [
  1. | `Found
  2. | `Not_found
  3. | `Pos of int * found
]
val search_physical : t -> contained:t -> search_result
val subst_found : t -> subst:t -> found -> t
module With_layout : sig ... end
exception Of_sexp_error of Base.Exn.t * t
val of_float_style : [ `Underscores | `No_underscores ] Base.Ref.t
val of_int_style : [ `Underscores | `No_underscores ] Base.Ref.t
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 -> (Base.Int.t -> '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 -> Sexplib0.Sexp.t) -> 'a no_raise -> Sexplib0.Sexp.t
val no_raise_of_sexp : (Sexplib0.Sexp.t -> 'a) -> Sexplib0.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
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct