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

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

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

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

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

include Ordering.Export