package async_unix

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
include module type of struct include Core.Sexp end
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
include Bin_prot.Binable.S_only_functions 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

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
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 = Core.Sexp.O
include Core.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 = Core.Sexp.comparator_witness
val comparator : (t, comparator_witness) Base__Comparator.comparator
val validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check
val validate_bound : min:t Core.Maybe_bound.t -> max:t Core.Maybe_bound.t -> t Validate.check
module Replace_polymorphic_compare = Core.Sexp.Replace_polymorphic_compare
module Map = Core.Sexp.Map
module Set = Core.Sexp.Set
include Core.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 = Core.Sexp.Parse_pos
module Cont_state = Core.Sexp.Cont_state
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 = Core.Sexp.Annotated
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 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 = Core.Sexp.Of_string_conv_exn
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 = Core.Sexp.With_layout
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_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 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 = Core.Sexp.Sexp_maybe

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 = Core.Sexp.With_text

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 = Core.Sexp.Stable
val save : ?perm:int -> string -> t -> unit
  • alert blocking Use [Writer.save_sexp ~hum:false] to avoid blocking.
val save_hum : ?perm:int -> string -> t -> unit
  • alert blocking Use [Writer.save_sexp ~hum:true] to avoid blocking.
val save_mach : ?perm:int -> string -> t -> unit
  • alert blocking Use [Writer.save_sexp ~hum:false] to avoid blocking.
val save_sexps : ?perm:int -> string -> t list -> unit
  • alert blocking Use [Writer.save_sexps ~hum:false] to avoid blocking.
val save_sexps_hum : ?perm:int -> string -> t list -> unit
  • alert blocking Use [Writer.save_sexps ~hum:true] to avoid blocking.
val save_sexps_mach : ?perm:int -> string -> t list -> unit
  • alert blocking Use [Writer.save_sexps ~hum:false] to avoid blocking.
OCaml

Innovation. Community. Security.