# 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 Linked_queue: Linked_queue

    module Random: Core_random

    module Char: Core_char

    module Ordering: Ordering

    module Bool: Bool

    module Int: Core_int

    val (%) : Int.t -> Int.t -> Int.t

    val (/%) : Int.t -> Int.t -> Int.t

    val (//) : Int.t -> Int.t -> float

    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 Either.Export

    include Typerep_lib.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_lib.Std.Make_typename.Make1(sig
    type 'a t = 'a Std_internal.sexp_array

    val name : stringend)

    val typename_of_sexp_array : 'a Typerep_lib.Typename.t ->
           'a sexp_array Typerep_lib.Typename.t

    val typerep_of_sexp_array : 'a.
             'a Typerep_lib.Std.Typerep.t ->
             'a sexp_array Typerep_lib.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_lib.Std.Make_typename.Make0(sig
    type t = Std_internal.sexp_bool

    val name : stringend)

    val typename_of_sexp_bool : sexp_bool Typerep_lib.Typename.t

    val typerep_of_sexp_bool : sexp_bool Typerep_lib.Std.Typerep.t

    val compare_sexp_bool : sexp_bool -> sexp_bool -> int

    val bin_size_sexp_bool : bool Bin_prot.Size.sizer

    val bin_write_sexp_bool : bool Bin_prot.Write.writer

    val bin_writer_sexp_bool : bool Bin_prot.Type_class.writer

    val __bin_read_sexp_bool__ : (int -> bool) Bin_prot.Read.reader

    val bin_read_sexp_bool : bool Bin_prot.Read.reader

    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_lib.Std.Make_typename.Make1(sig
    type 'a t = 'a Std_internal.sexp_list

    val name : stringend)

    val typename_of_sexp_list : 'a Typerep_lib.Typename.t -> 'a sexp_list Typerep_lib.Typename.t

    val typerep_of_sexp_list : 'a.
             'a Typerep_lib.Std.Typerep.t ->
             'a sexp_list Typerep_lib.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_lib.Std.Make_typename.Make1(sig
    type 'a t = 'a Std_internal.sexp_option

    val name : stringend)

    val typename_of_sexp_option : 'a Typerep_lib.Typename.t ->
           'a sexp_option Typerep_lib.Typename.t

    val typerep_of_sexp_option : 'a.
             'a Typerep_lib.Std.Typerep.t ->
             'a sexp_option Typerep_lib.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_lib.Std.Make_typename.Make1(sig
    type 'a t = 'a Std_internal.sexp_opaque

    val name : stringend)

    val typename_of_sexp_opaque : 'a Typerep_lib.Typename.t ->
           'a sexp_opaque Typerep_lib.Typename.t

    val typerep_of_sexp_opaque : 'a.
             'a Typerep_lib.Std.Typerep.t ->
             'a sexp_opaque Typerep_lib.Std.Typerep.t

    val compare_sexp_opaque : 'a.
             ('a -> 'a -> int) ->
             'a sexp_opaque -> 'a sexp_opaque -> int

    val bin_size_sexp_opaque : 'a -> 'a

    val bin_write_sexp_opaque : 'a -> 'a

    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 -> 'a

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