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 Set: Core_set
module Map: Core_map
module Array: Core_array
include Array.Infix
module Hashtbl: Core_hashtbl
module String: Core_string
module List: sig .. end
include List.Infix
module Queue: Core_queue
module Random: Core_random
module Char: Core_char
module Ordering: Ordering
module Bool: Bool
module Int: Core_int
include Int.Infix
module Int32: Core_int32
module Int64: Core_int64
module Nativeint: Core_nativeint
module Lazy: Core_lazy
module Field: Core_field
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: Core_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 Typerep_kernel.Std_internal
include struct ... end
val sexp_of_exn : Exn.t -> Sexplib.Sexp.t
type 'a sexp_array = 'a array 
module Typename_of_sexp_array: Typerep_kernel.Std.Make_typename.Make1(sig
type 'a t = 'a Std_internal.sexp_array 



val name : string
end)
val typename_of_sexp_array : 'a Typerep_kernel.Typename.t ->
       'a sexp_array Typerep_kernel.Typename.t
val typerep_of_sexp_array : 'a.
         'a Typerep_kernel.Std.Typerep.t ->
         'a sexp_array Typerep_kernel.Std.Typerep.t
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.Write.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.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> int -> 'a array
val bin_read_sexp_array : 'a Bin_prot.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> 'a array
val bin_reader_sexp_array : 'a Bin_prot.Type_class.reader -> 'a array Bin_prot.Type_class.reader
val bin_sexp_array : 'a Bin_prot.Type_class.t -> 'a 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 
module Typename_of_sexp_bool: Typerep_kernel.Std.Make_typename.Make0(sig
type t = Std_internal.sexp_bool 



val name : string
end)
val typename_of_sexp_bool : sexp_bool Typerep_kernel.Typename.t
val typerep_of_sexp_bool : sexp_bool Typerep_kernel.Std.Typerep.t
val compare_sexp_bool : sexp_bool -> sexp_bool -> int
val bin_size_sexp_bool : bool -> int
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.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> int -> bool
val bin_read_sexp_bool : Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> bool
val bin_reader_sexp_bool : bool Bin_prot.Type_class.reader
val bin_sexp_bool : 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 
module Typename_of_sexp_list: Typerep_kernel.Std.Make_typename.Make1(sig
type 'a t = 'a Std_internal.sexp_list 



val name : string
end)
val typename_of_sexp_list : 'a Typerep_kernel.Typename.t ->
       'a sexp_list Typerep_kernel.Typename.t
val typerep_of_sexp_list : 'a.
         'a Typerep_kernel.Std.Typerep.t ->
         'a sexp_list Typerep_kernel.Std.Typerep.t
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.Write.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.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> int -> 'a list
val bin_read_sexp_list : 'a Bin_prot.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> 'a list
val bin_reader_sexp_list : 'a Bin_prot.Type_class.reader -> 'a list Bin_prot.Type_class.reader
val bin_sexp_list : 'a Bin_prot.Type_class.t -> 'a 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 
module Typename_of_sexp_option: Typerep_kernel.Std.Make_typename.Make1(sig
type 'a t = 'a Std_internal.sexp_option 



val name : string
end)
val typename_of_sexp_option : 'a Typerep_kernel.Typename.t ->
       'a sexp_option Typerep_kernel.Typename.t
val typerep_of_sexp_option : 'a.
         'a Typerep_kernel.Std.Typerep.t ->
         'a sexp_option Typerep_kernel.Std.Typerep.t
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.Write.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.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> int -> 'a option
val bin_read_sexp_option : 'a Bin_prot.Read.reader ->
       Bin_prot.Common.buf -> pos_ref:Bin_prot.Common.pos_ref -> 'a option
val bin_reader_sexp_option : 'a Bin_prot.Type_class.reader -> 'a option Bin_prot.Type_class.reader
val bin_sexp_option : 'a Bin_prot.Type_class.t -> 'a 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 
module Typename_of_sexp_opaque: Typerep_kernel.Std.Make_typename.Make1(sig
type 'a t = 'a Std_internal.sexp_opaque 



val name : string
end)
val typename_of_sexp_opaque : 'a Typerep_kernel.Typename.t ->
       'a sexp_opaque Typerep_kernel.Typename.t
val typerep_of_sexp_opaque : 'a.
         'a Typerep_kernel.Std.Typerep.t ->
         'a sexp_opaque Typerep_kernel.Std.Typerep.t
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 -> pos:'b -> 'c -> 'd) -> 'a -> pos:'b -> 'c -> 'd
val bin_writer_sexp_opaque : 'a Bin_prot.Type_class.writer -> 'a Bin_prot.Type_class.writer
val __bin_read_sexp_opaque__ : 'a -> 'b -> pos_ref:Bin_prot.Common.pos Pervasives.ref -> 'c -> 'd
val bin_read_sexp_opaque : ('a -> pos_ref:'b -> 'c) -> 'a -> pos_ref:'b -> 'c
val bin_reader_sexp_opaque : 'a Bin_prot.Type_class.reader -> 'a Bin_prot.Type_class.reader
val bin_sexp_opaque : 'a Bin_prot.Type_class.t -> 'a 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).