Previous  Up  Next

Module Std_internal

module Std_internal: sig .. end
stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (otherwise, the implementation in terms of Set.t would hide a heavyweight functor instantiation at each call).
module Big_int: Sexplib.Std.Big_int
module Nat: Sexplib.Std.Nat
module Ratio: Sexplib.Std.Ratio
module Num: Sexplib.Std.Num
module Set: Set
module Map: Map
module Array: Array
include Array.Infix
module Hashtbl: Hashtbl
module String: String
module List: sig .. end
include List.Infix
module Queue: Queue
module Random: Random
module Stack: Stack
module Sys: Sys
module Char: Char
module Bool: Bool
module Int: Int
include Int.Infix
module Int32: Int32
module Int64: Int64
module Nativeint: Nativeint
module Lazy: Lazy
include Common
include Float
include String.Infix
val round : Float.t -> Float.t
include Interfaces
module Sexp: Sexp
include Sexplib.Conv
include Printf
include Scanf
include Bin_prot.Std
type 'a sexp_option = 'a option 
val compare_sexp_option : 'a.
         ('a -> 'a -> int) ->
         'a sexp_option -> 'a sexp_option -> int
val bin_size_sexp_option : 'a sizer -> 'a option -> int
val bin_write_sexp_option_ : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Unsafe_common.sptr ->
       Bin_prot.Unsafe_common.eptr -> 'a option -> Bin_prot.Unsafe_common.sptr
val bin_write_sexp_option : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Common.buf ->
       pos:Bin_prot.Common.pos -> 'a option -> Bin_prot.Common.pos
val bin_writer_sexp_option : 'a Bin_prot.Type_class.writer -> 'a option Bin_prot.Type_class.writer
val bin_read_sexp_option__ : 'a -> 'b -> 'c -> 'd -> 'e
val bin_read_sexp_option_ : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr -> Bin_prot.Unsafe_common.eptr -> 'a option
val bin_read_sexp_option : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Common.buf ->
       pos_ref:Bin_prot.Common.pos Pervasives.ref -> 'a sexp_option
val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader ->
       'a sexp_option Bin_prot.Type_class.reader
val bin_sexp_option : 'a Bin_prot.Type_class.t -> 'a sexp_option Bin_prot.Type_class.t

stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (otherwise, the implementation in terms of Set.t would hide a heavyweight functor instantiation at each call).
type 'a sexp_list = 'a list 
val compare_sexp_list : 'a.
         ('a -> 'a -> int) ->
         'a sexp_list -> 'a sexp_list -> int
val bin_size_sexp_list : 'a sizer -> 'a list -> int
val bin_write_sexp_list_ : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Unsafe_common.sptr ->
       Bin_prot.Unsafe_common.eptr -> 'a list -> Bin_prot.Unsafe_common.sptr
val bin_write_sexp_list : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Common.buf ->
       pos:Bin_prot.Common.pos -> 'a list -> Bin_prot.Common.pos
val bin_writer_sexp_list : 'a Bin_prot.Type_class.writer -> 'a list Bin_prot.Type_class.writer
val bin_read_sexp_list__ : 'a -> 'b -> 'c -> 'd -> 'e
val bin_read_sexp_list_ : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr -> Bin_prot.Unsafe_common.eptr -> 'a list
val bin_read_sexp_list : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Common.buf ->
       pos_ref:Bin_prot.Common.pos Pervasives.ref -> 'a sexp_list
val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader ->
       'a sexp_list Bin_prot.Type_class.reader
val bin_sexp_list : 'a Bin_prot.Type_class.t -> 'a sexp_list Bin_prot.Type_class.t

stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (otherwise, the implementation in terms of Set.t would hide a heavyweight functor instantiation at each call).
type 'a sexp_array = 'a array 
val compare_sexp_array : 'a.
         ('a -> 'a -> int) ->
         'a sexp_array -> 'a sexp_array -> int
val bin_size_sexp_array : 'a sizer -> 'a array -> int
val bin_write_sexp_array_ : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Unsafe_common.sptr ->
       Bin_prot.Unsafe_common.eptr -> 'a array -> Bin_prot.Unsafe_common.sptr
val bin_write_sexp_array : 'a Bin_prot.Unsafe_write_c.writer ->
       Bin_prot.Common.buf ->
       pos:Bin_prot.Common.pos -> 'a array -> Bin_prot.Common.pos
val bin_writer_sexp_array : 'a Bin_prot.Type_class.writer -> 'a array Bin_prot.Type_class.writer
val bin_read_sexp_array__ : 'a -> 'b -> 'c -> 'd -> 'e
val bin_read_sexp_array_ : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr -> Bin_prot.Unsafe_common.eptr -> 'a array
val bin_read_sexp_array : 'a Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Common.buf ->
       pos_ref:Bin_prot.Common.pos Pervasives.ref -> 'a sexp_array
val bin_reader_sexp_array : 'a Bin_prot.Type_class.reader ->
       'a sexp_array Bin_prot.Type_class.reader
val bin_sexp_array : 'a Bin_prot.Type_class.t -> 'a sexp_array Bin_prot.Type_class.t

stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (otherwise, the implementation in terms of Set.t would hide a heavyweight functor instantiation at each call).
type 'a sexp_opaque = 'a 
val compare_sexp_opaque : 'a.
         ('a -> 'a -> int) ->
         'a sexp_opaque -> 'a sexp_opaque -> int
val bin_size_sexp_opaque : ('a -> 'b) -> 'a -> 'b
val bin_write_sexp_opaque_ : ('a -> 'b -> 'c -> 'd) -> 'a -> 'b -> 'c -> 'd
val bin_write_sexp_opaque : (Bin_prot.Unsafe_common.sptr ->
        Bin_prot.Unsafe_common.eptr -> 'a -> Bin_prot.Unsafe_common.sptr) ->
       Bin_prot.Common.buf -> pos:Bin_prot.Common.pos -> 'a -> Bin_prot.Common.pos
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer -> 'a Bin_prot.Type_class.writer
val bin_read_sexp_opaque__ : 'a -> 'b -> 'c -> 'd -> 'e
val bin_read_sexp_opaque_ : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
val bin_read_sexp_opaque : (Bin_prot.Unsafe_common.sptr_ptr ->
        Bin_prot.Unsafe_common.eptr -> 'a sexp_opaque) ->
       Bin_prot.Common.buf ->
       pos_ref:Bin_prot.Common.pos Pervasives.ref -> 'a sexp_opaque
val bin_reader_sexp_opaque : 'a sexp_opaque Bin_prot.Type_class.reader ->
       'a sexp_opaque Bin_prot.Type_class.reader
val bin_sexp_opaque : 'a sexp_opaque Bin_prot.Type_class.t ->
       'a sexp_opaque Bin_prot.Type_class.t

stable_dedup Same as dedup but maintains the order of the list and doesn't allow compare function to be specified (otherwise, the implementation in terms of Set.t would hide a heavyweight functor instantiation at each call).
include Result.Export
val sexp_of_array : ('a -> Sexplib.Sexp.t) -> 'a Array.t -> Sexplib.Sexp.t
val array_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Array.t
val sexp_of_bool : Bool.t -> Sexplib.Sexp.t
val bool_of_sexp : Sexplib.Sexp.t -> Bool.t
val sexp_of_char : Char.t -> Sexplib.Sexp.t
val char_of_sexp : Sexplib.Sexp.t -> Char.t
val sexp_of_exn : Exn.t -> Sexplib.Sexp.t
val sexp_of_float : Float.t -> Sexplib.Sexp.t
val float_of_sexp : Sexplib.Sexp.t -> Float.t
val sexp_of_int : Int.t -> Sexplib.Sexp.t
val int_of_sexp : Sexplib.Sexp.t -> Int.t
val sexp_of_int32 : Int32.t -> Sexplib.Sexp.t
val int32_of_sexp : Sexplib.Sexp.t -> Int32.t
val sexp_of_int64 : Int64.t -> Sexplib.Sexp.t
val int64_of_sexp : Sexplib.Sexp.t -> Int64.t
val sexp_of_list : ('a -> Sexplib.Sexp.t) -> 'a List.t -> Sexplib.Sexp.t
val list_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a List.t
val sexp_of_nativeint : Nativeint.t -> Sexplib.Sexp.t
val nativeint_of_sexp : Sexplib.Sexp.t -> Nativeint.t
val sexp_of_option : ('a -> Sexplib.Sexp.t) -> 'a Option.t -> Sexplib.Sexp.t
val option_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Option.t
val sexp_of_string : String.t -> Sexplib.Sexp.t
val string_of_sexp : Sexplib.Sexp.t -> String.t
val lazy_t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a Lazy.t
val sexp_of_lazy_t : ('a -> Sexplib.Sexp.t) -> 'a Lazy.t -> Sexplib.Sexp.t