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).
val __pa_ounit_275876e34cf609db118f3d84b799a790 : string
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 Ordering: Ordering
module Bool: Bool
module Int: Int
include Int.Infix
module Int32: Int32
module Int64: Int64
module Nativeint: Nativeint
module Lazy: Lazy
module Ref: Ref
include Common
include Float
include String.Infix
val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> Float.t -> Float.t
include Interfaces
module Sexp: Sexp
include Sexplib.Conv
val printf : ('a, Pervasives.out_channel, unit) Pervasives.format -> 'a
val bprintf : Buffer.t -> ('a, Buffer.t, unit) Pervasives.format -> 'a
val eprintf : ('a, Pervasives.out_channel, unit) Pervasives.format -> 'a
val fprintf : Pervasives.out_channel ->
       ('a, Pervasives.out_channel, unit) Pervasives.format -> 'a
val sprintf : ('a, unit, string) Pervasives.format -> 'a
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Pervasives.format4 -> 'b
include Result.Export
include struct ... end
val sexp_of_exn : Exn.t -> Sexplib.Sexp.t
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 Bin_prot.Size.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 Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr ->
       Bin_prot.Unsafe_common.eptr -> int -> 'a array
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 sexp_bool = bool 
val compare_sexp_bool : sexp_bool -> sexp_bool -> int
val bin_size_sexp_bool : bool -> int
val bin_write_sexp_bool_ : Bin_prot.Unsafe_common.sptr ->
       Bin_prot.Unsafe_common.eptr -> bool -> Bin_prot.Unsafe_common.sptr
val bin_write_sexp_bool : Bin_prot.Common.buf -> pos:Bin_prot.Common.pos -> bool -> Bin_prot.Common.pos
val bin_writer_sexp_bool : bool Bin_prot.Type_class.writer
val bin_read_sexp_bool__ : Bin_prot.Unsafe_common.sptr_ptr -> Bin_prot.Unsafe_common.eptr -> int -> bool
val bin_read_sexp_bool_ : Bin_prot.Unsafe_common.sptr_ptr -> Bin_prot.Unsafe_common.eptr -> bool
val bin_read_sexp_bool : Bin_prot.Common.buf ->
       pos_ref:Bin_prot.Common.pos Pervasives.ref -> sexp_bool
val bin_reader_sexp_bool : sexp_bool Bin_prot.Type_class.reader
val bin_sexp_bool : sexp_bool 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 Bin_prot.Size.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 Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr ->
       Bin_prot.Unsafe_common.eptr -> int -> 'a list
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_option = 'a option 
val compare_sexp_option : 'a.
         ('a -> 'a -> int) ->
         'a sexp_option -> 'a sexp_option -> int
val bin_size_sexp_option : 'a Bin_prot.Size.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 Bin_prot.Unsafe_read_c.reader ->
       Bin_prot.Unsafe_common.sptr_ptr ->
       Bin_prot.Unsafe_common.eptr -> int -> 'a option
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_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 Ordering.Export

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).