# Module Std_kernel.Int_conversions

    module Int_conversions: Int_conversions

    val int_to_int32 : int -> int32 option

Ocaml has the following integer types, with the following bit widths on 32-bit and 64-bit architectures.

                                arch  arch
                    type        32b   64b
                    ----------------------
                    int          31    63  (32 when compiled to JavaScript)
                    nativeint    32    64
                    int32        32    32
                    int64        64    64

In both cases, the following inequalities hold:

          width(int) < width(nativeint)
          && width(int32) <= width(nativeint) <= width(int64)

The conversion functions come in one of two flavors.

If width(foo) <= width(bar) on both 32-bit and 64-bit architectures, then we have

     val foo_to_bar : foo -> bar

otherwise we have

          val foo_to_bar     : foo -> bar option
          val foo_to_bar_exn : foo -> bar

    val int_to_int32_exn : int -> int32

    val int_to_int64 : int -> int64

    val int_to_nativeint : int -> nativeint

    val int32_to_int : int32 -> int option

    val int32_to_int_exn : int32 -> int

    val int32_to_int64 : int32 -> int64

    val int32_to_nativeint : int32 -> nativeint

    val int64_to_int : int64 -> int option

    val int64_to_int_exn : int64 -> int

    val int64_to_int32 : int64 -> int32 option

    val int64_to_int32_exn : int64 -> int32

    val int64_to_nativeint : int64 -> nativeint option

    val int64_to_nativeint_exn : int64 -> nativeint

    val nativeint_to_int : nativeint -> int option

    val nativeint_to_int_exn : nativeint -> int

    val nativeint_to_int32 : nativeint -> int32 option

    val nativeint_to_int32_exn : nativeint -> int32

    val nativeint_to_int64 : nativeint -> int64

    val num_bits_int : int

    val num_bits_int32 : int

    val num_bits_int64 : int

    val num_bits_nativeint : int

    module Make: functor (I : sig
    type t

    val to_string : t -> stringend) -> sig .. end

human-friendly string (and possibly sexp) conversions

    module Make_hex: functor (I : sig
    type t

    val typerep_of_t : t Typerep_lib.Std.Typerep.t
    val typename_of_t : t Typerep_lib.Std.Typename.t
    to_string and of_string convert between t and unsigned,
                           unprefixed hexadecimal

    val to_string : t -> string
    val of_string : string -> t
    val zero : t
    val (<) : t -> t -> bool
    val neg : t -> t
    val module_name : string
    val compare : t -> t -> int
    val bin_t : t Bin_prot.Type_class.t
    val bin_read_t : t Bin_prot.Read.reader
    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
    val bin_reader_t : t Bin_prot.Type_class.reader
    val bin_size_t : t Bin_prot.Size.sizer
    val bin_write_t : t Bin_prot.Write.writer
    val bin_writer_t : t Bin_prot.Type_class.writer
    to_string and of_string convert between t and unsigned,
                           unprefixed hexadecimal

    end) -> Int_intf.Hexable  with type t := I.t

    val sexp_of_int_style : [ `No_underscores | `Underscores ] Pervasives.ref

global ref affecting whether the `sexp_of_t` returned by `Make` is consistent with the `to_string` input or the `to_string_hum` output

    val insert_delimiter_every : string -> delimiter:char -> chars_per_delimiter:int -> string

utility for defining to_string_hum on numeric types -- takes a string matching (-|+)?`0-9a-fA-F`+ and puts `delimiter` every `chars_per_delimiter` characters starting from the right.

    val insert_delimiter : string -> delimiter:char -> string

`insert_delimiter_every ~chars_per_delimiter:3`

    val insert_underscores : string -> string

`insert_delimiter ~delimiter:'_'`