Module Base.Export

include Sexp.Private.Raw_grammar.Builtin
val unit_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val bool_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val string_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val bytes_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val char_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val float_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int32_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val int64_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val nativeint_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val ref_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val lazy_t_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val option_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val list_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
val array_sexp_grammar : Sexplib0.Sexp.Private.Raw_grammar.t
type 'a array = 'a Array.t
val compare_array : a. ('a -> 'a -> int) -> 'a array -> 'a array -> int
val equal_array : a. ('a -> 'a -> bool) -> 'a array -> 'a array -> bool
val array_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a array
val sexp_of_array : a. ('a -> Sexp.t) -> 'a array -> Sexp.t
val array_sexp_grammar : Sexp.Private.Raw_grammar.t
type bool = Bool.t
val compare_bool : bool -> bool -> int
val equal_bool : bool -> bool -> bool
val hash_fold_bool : Hash.state -> bool -> Hash.state
val hash_bool : bool -> Hash.hash_value
val bool_of_sexp : Sexp.t -> bool
val sexp_of_bool : bool -> Sexp.t
val bool_sexp_grammar : Sexp.Private.Raw_grammar.t
type char = Char.t
val compare_char : char -> char -> int
val equal_char : char -> char -> bool
val hash_fold_char : Hash.state -> char -> Hash.state
val hash_char : char -> Hash.hash_value
val char_of_sexp : Sexp.t -> char
val sexp_of_char : char -> Sexp.t
val char_sexp_grammar : Sexp.Private.Raw_grammar.t
type exn = Exn.t
val sexp_of_exn : exn -> Sexp.t
type float = Float.t
val compare_float : float -> float -> int
val equal_float : float -> float -> bool
val hash_fold_float : Hash.state -> float -> Hash.state
val hash_float : float -> Hash.hash_value
val float_of_sexp : Sexp.t -> float
val sexp_of_float : float -> Sexp.t
val float_sexp_grammar : Sexp.Private.Raw_grammar.t
type int = Int.t
val compare_int : int -> int -> int
val equal_int : int -> int -> bool
val hash_fold_int : Hash.state -> int -> Hash.state
val hash_int : int -> Hash.hash_value
val int_of_sexp : Sexp.t -> int
val sexp_of_int : int -> Sexp.t
val int_sexp_grammar : Sexp.Private.Raw_grammar.t
type int32 = Int32.t
val compare_int32 : int32 -> int32 -> int
val equal_int32 : int32 -> int32 -> bool
val hash_fold_int32 : Hash.state -> int32 -> Hash.state
val hash_int32 : int32 -> Hash.hash_value
val int32_of_sexp : Sexp.t -> int32
val sexp_of_int32 : int32 -> Sexp.t
val int32_sexp_grammar : Sexp.Private.Raw_grammar.t
type int64 = Int64.t
val compare_int64 : int64 -> int64 -> int
val equal_int64 : int64 -> int64 -> bool
val hash_fold_int64 : Hash.state -> int64 -> Hash.state
val hash_int64 : int64 -> Hash.hash_value
val int64_of_sexp : Sexp.t -> int64
val sexp_of_int64 : int64 -> Sexp.t
val int64_sexp_grammar : Sexp.Private.Raw_grammar.t
type 'a list = 'a List.t
val compare_list : a. ('a -> 'a -> int) -> 'a list -> 'a list -> int
val equal_list : a. ('a -> 'a -> bool) -> 'a list -> 'a list -> bool
val hash_fold_list : a. (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a list -> Hash.state
val list_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a list
val sexp_of_list : a. ('a -> Sexp.t) -> 'a list -> Sexp.t
val list_sexp_grammar : Sexp.Private.Raw_grammar.t
type nativeint = Nativeint.t
val compare_nativeint : nativeint -> nativeint -> int
val equal_nativeint : nativeint -> nativeint -> bool
val hash_fold_nativeint : Hash.state -> nativeint -> Hash.state
val hash_nativeint : nativeint -> Hash.hash_value
val nativeint_of_sexp : Sexp.t -> nativeint
val sexp_of_nativeint : nativeint -> Sexp.t
val nativeint_sexp_grammar : Sexp.Private.Raw_grammar.t
type 'a option = 'a Option.t
val compare_option : a. ('a -> 'a -> int) -> 'a option -> 'a option -> int
val equal_option : a. ('a -> 'a -> bool) -> 'a option -> 'a option -> bool
val hash_fold_option : a. (Hash.state -> 'a -> Hash.state) -> Hash.state -> 'a option -> Hash.state
val option_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a option
val sexp_of_option : a. ('a -> Sexp.t) -> 'a option -> Sexp.t
val option_sexp_grammar : Sexp.Private.Raw_grammar.t
type 'a ref = 'a Ref.t
val compare_ref : a. ('a -> 'a -> int) -> 'a ref -> 'a ref -> int
val equal_ref : a. ('a -> 'a -> bool) -> 'a ref -> 'a ref -> bool
val ref_of_sexp : a. (Sexp.t -> 'a) -> Sexp.t -> 'a ref
val sexp_of_ref : a. ('a -> Sexp.t) -> 'a ref -> Sexp.t
val ref_sexp_grammar : Sexp.Private.Raw_grammar.t
type string = String.t
val compare_string : string -> string -> int
val equal_string : string -> string -> bool
val hash_fold_string : Hash.state -> string -> Hash.state
val hash_string : string -> Hash.hash_value
val string_of_sexp : Sexp.t -> string
val sexp_of_string : string -> Sexp.t
val string_sexp_grammar : Sexp.Private.Raw_grammar.t
type bytes = Bytes.t
val compare_bytes : bytes -> bytes -> int
val equal_bytes : bytes -> bytes -> bool
val bytes_of_sexp : Sexp.t -> bytes
val sexp_of_bytes : bytes -> Sexp.t
val bytes_sexp_grammar : Sexp.Private.Raw_grammar.t
type unit = Unit.t
val compare_unit : unit -> unit -> int
val equal_unit : unit -> unit -> bool
val hash_fold_unit : Hash.state -> unit -> Hash.state
val hash_unit : unit -> Hash.hash_value
val unit_of_sexp : Sexp.t -> unit
val sexp_of_unit : unit -> Sexp.t
val unit_sexp_grammar : Sexp.Private.Raw_grammar.t
type nonrec ('a, 'b, 'c) format = ('a, 'b, 'c) Stdlib.format
type nonrec ('a, 'b, 'c, 'd) format4 = ('a, 'b, 'c, 'd) Stdlib.format4
type nonrec ('a, 'b, 'c, 'd, 'e, 'f) format6 = ('a, 'b, 'c, 'd, 'e, 'f) Stdlib.format6

Sexp

Exporting the ad-hoc types that are recognized by ppx_sexp_* converters. sexp_array, sexp_list, and sexp_option allow a record field to be absent when converting from a sexp, and if absent, the field will take a default value of the appropriate type:

        sexp_array   [||]
        sexp_bool    false
        sexp_list    []
        sexp_option  None

sexp_opaque causes the conversion to sexp to produce the atom <opaque>.

For more documentation, see sexplib/README.md.

type 'a sexp_array = 'a array
type 'a sexp_list = 'a list
type 'a sexp_opaque = 'a
type 'a sexp_option = 'a option
include List.Infix
val (@) : 'a Base__List.t -> 'a Base__List.t -> 'a Base__List.t
include Int.O
val (+) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (-) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (*) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (~-) : Base__Int.t -> Base__Int.t
val (**) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (>=) : Base__Int.t -> Base__Int.t -> bool
val (<=) : Base__Int.t -> Base__Int.t -> bool
val (=) : Base__Int.t -> Base__Int.t -> bool
val (>) : Base__Int.t -> Base__Int.t -> bool
val (<) : Base__Int.t -> Base__Int.t -> bool
val (<>) : Base__Int.t -> Base__Int.t -> bool
val abs : Base__Int.t -> Base__Int.t
val neg : Base__Int.t -> Base__Int.t
val zero : Base__Int.t
val (%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (/%) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (//) : Base__Int.t -> Base__Int.t -> float
val (land) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lxor) : Base__Int.t -> Base__Int.t -> Base__Int.t
val (lnot) : Base__Int.t -> Base__Int.t
val (lsl) : Base__Int.t -> int -> Base__Int.t
val (asr) : Base__Int.t -> int -> Base__Int.t
val (lsr) : Base__Int.t -> int -> Base__Int.t
include Base__.Import.Int_replace_polymorphic_compare
val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (<>) : int -> int -> bool
val (=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val compare : int -> int -> int
val ascending : int -> int -> int
val descending : int -> int -> int
val equal : int -> int -> bool
val max : int -> int -> int
val min : int -> int -> int
include Float.O_dot
val (+.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (-.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (*.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (/.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (**.) : Base__Float.t -> Base__Float.t -> Base__Float.t
val (~-.) : Base__Float.t -> Base__Float.t
val (|>) : 'a -> ('a -> 'b) -> 'b

Reverse application operator. x |> g |> f is equivalent to f (g (x)).

val (@@) : ('a -> 'b) -> 'a -> 'b

Application operator. g @@ f @@ x is equivalent to g (f (x)).

val (&&) : bool -> bool -> bool
val (||) : bool -> bool -> bool
val not : bool -> bool
val ignore : _ -> unit
val (^) : String.t -> String.t -> String.t

Common string operations

val (!) : 'a ref -> 'a
val ref : 'a -> 'a ref
val (:=) : 'a ref -> 'a -> unit
val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
val raise : exn -> _
val failwith : string -> 'a
val invalid_arg : string -> 'a
val raise_s : Sexp.t -> 'a
val phys_equal : 'a -> 'a -> bool
val force : 'a Lazy.t -> 'a