package core

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type

This module extends Base.Int.

val globalize : int -> int
val t_sexp_grammar : int Sexplib0.Sexp_grammar.t
val of_float : float -> int
val to_float : int -> float
val of_int_exn : int -> int
val to_int_exn : int -> int
type comparator_witness = Base.Int.comparator_witness
val is_positive : int -> bool
val is_non_negative : int -> bool
val is_negative : int -> bool
val is_non_positive : int -> bool
val sign : int -> Base__Comparable_intf.Sign.t
val compare__local : int Base__Ppx_compare_lib.compare__local
val equal__local : int Base__Ppx_compare_lib.equal__local
val invariant : int Base__Invariant_intf.inv
val of_string_opt : string -> int option
val to_string_hum : ?delimiter:char -> int -> string
val one : int
val minus_one : int
val rem : int -> int -> int
val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> int -> to_multiple_of:int -> int
val round_towards_zero : int -> to_multiple_of:int -> int
val round_down : int -> to_multiple_of:int -> int
val round_up : int -> to_multiple_of:int -> int
val round_nearest : int -> to_multiple_of:int -> int
val succ : int -> int
val pred : int -> int
val pow : int -> int -> int
val bit_and : int -> int -> int
val bit_or : int -> int -> int
val bit_xor : int -> int -> int
val bit_not : int -> int
val popcount : int -> int
val shift_left : int -> int -> int
val shift_right : int -> int -> int
val decr : int Base__.Import.ref -> unit
val incr : int Base__.Import.ref -> unit
val of_int32_exn : int32 -> int
val to_int32_exn : int -> int32
val of_int64_exn : int64 -> int
val to_int64 : int -> int64
val of_nativeint_exn : nativeint -> int
val to_nativeint_exn : int -> nativeint
val of_float_unchecked : float -> int
val num_bits : int
val max_value : int
val min_value : int
val shift_right_logical : int -> int -> int
val ceil_pow2 : int -> int
val floor_pow2 : int -> int
val ceil_log2 : int -> int
val floor_log2 : int -> int
val is_pow2 : int -> bool
val clz : int -> int
val ctz : int -> int
module O : sig ... end
val (+) : int -> int -> int
val (-) : int -> int -> int
val (*) : int -> int -> int
val (/) : int -> int -> int
val (~-) : int -> int
val (**) : int -> int -> int
val (land) : int -> int -> int
val (lor) : int -> int -> int
val (lxor) : int -> int -> int
val lnot : int -> int
val abs : int -> int
val neg : int -> int
val zero : int
val (%) : int -> int -> int
val (/%) : int -> int -> int
val (//) : int -> int -> float
val (lsl) : int -> int -> int
val (asr) : int -> int -> int
val (lsr) : int -> int -> int
val max_value_30_bits : int
val of_int : int -> int
val to_int : int -> int
val of_int32 : int32 -> int option
val to_int32 : int -> int32 option
val of_int64 : int64 -> int option
val of_nativeint : nativeint -> int option
val to_nativeint : int -> nativeint
val to_int32_trunc : int -> int32
val of_int32_trunc : int32 -> int
val of_int64_trunc : int64 -> int
val of_nativeint_trunc : nativeint -> int
val bswap16 : int -> int
module Private : sig ... end

Note that int is already stable by itself, since as a primitive type it is an integral part of the sexp / bin_io protocol. Int.Stable exists only to introduce Int.Stable.Set and Int.Stable.Map, and provide interface uniformity with other stable types.

include Int_intf.Extension_with_stable with type t := {t}1 and type comparator_witness := comparator_witness
include Int_intf.Extension with type t := {t}1 with type comparator_witness := comparator_witness
include Bin_prot.Binable.S with type t := {t}1
include Bin_prot.Binable.S_only_functions with type t := {t}1
include Typerep_lib.Typerepable.S with type t := {t}1
val typerep_of_t : {t}1 Typerep_lib.Std_internal.Typerep.t
val typename_of_t : {t}1 Typerep_lib.Typename.t
include Int_intf.Binaryable with type t := {t}1
module Binary : sig ... end
include Base.Int.Binaryable with type t := {t}1 and module Binary := Binary
include Int_intf.Hexable with type t := {t}1
module Hex : sig ... end
include Base.Int.Hexable with type t := {t}1 and module Hex := Hex
include Identifiable.S with type t := {t}1 with type comparator_witness := comparator_witness
include Bin_prot.Binable.S with type t := {t}1
include Bin_prot.Binable.S_only_functions with type t := {t}1
include Ppx_hash_lib.Hashable.S with type t := {t}1
include Sexplib0.Sexpable.S with type t := {t}1
val t_of_sexp : Sexplib0__.Sexp.t -> {t}1
include Ppx_compare_lib.Comparable.S with type t := {t}1
include Ppx_hash_lib.Hashable.S with type t := {t}1
val sexp_of_t : {t}1 -> Sexplib0.Sexp.t
val of_string : string -> {t}1
val to_string : {t}1 -> string
val pp : Base__.Formatter.t -> {t}1 -> unit
include Comparable.S_binable with type t := {t}1 with type comparator_witness := comparator_witness
include Base.Comparable.S with type t := {t}1 with type comparator_witness := comparator_witness
val (>=) : {t}1 -> {t}1 -> bool
val (<=) : {t}1 -> {t}1 -> bool
val (=) : {t}1 -> {t}1 -> bool
val (>) : {t}1 -> {t}1 -> bool
val (<) : {t}1 -> {t}1 -> bool
val (<>) : {t}1 -> {t}1 -> bool
val equal : {t}1 -> {t}1 -> bool
val compare : {t}1 -> {t}1 -> int
val min : {t}1 -> {t}1 -> {t}1
val max : {t}1 -> {t}1 -> {t}1
val ascending : {t}1 -> {t}1 -> int
val descending : {t}1 -> {t}1 -> int
val between : {t}1 -> low:{t}1 -> high:{t}1 -> bool
val clamp_exn : {t}1 -> min:{t}1 -> max:{t}1 -> {t}1
val clamp : {t}1 -> min:{t}1 -> max:{t}1 -> {t}1 Base__.Or_error.t
module Replace_polymorphic_compare : sig ... end
include Comparator.S with type t := {t}1 with type comparator_witness := comparator_witness
val comparator : ({t}1, comparator_witness) Comparator.comparator
module Map : Map.S_binable with type Key.t = {t}1 with type Key.comparator_witness = comparator_witness
module Set : Set.S_binable with type Elt.t = {t}1 with type Elt.comparator_witness = comparator_witness
include Hashable.S_binable with type t := {t}1
include Ppx_hash_lib.Hashable.S with type t := {t}1
val hash_fold_t : {t}1 Base__Ppx_hash_lib.hash_fold
val hash : {t}1 -> Base__Ppx_hash_lib.Std.Hash.hash_value
val hashable : {t}1 Core__.Hashtbl.Hashable.t
module Table : Hashtbl.S_binable with type key = {t}1
module Hash_set : Hash_set.S_binable with type elt = {t}1
module Hash_queue : Hash_queue.S with type key = {t}1
include Comparable.Validate_with_zero with type t := {t}1
val validate_lbound : min:{t}1 Maybe_bound.t -> {t}1 Validate.check
val validate_ubound : max:{t}1 Maybe_bound.t -> {t}1 Validate.check
val validate_bound : min:{t}1 Maybe_bound.t -> max:{t}1 Maybe_bound.t -> {t}1 Validate.check
val validate_positive : {t}1 Validate.check
val validate_non_negative : {t}1 Validate.check
val validate_negative : {t}1 Validate.check
val validate_non_positive : {t}1 Validate.check
include Quickcheckable.S_int with type t := {t}1
include Quickcheck_intf.S_range with type t := {t}1
include Quickcheck_intf.S with type t := {t}1
val quickcheck_generator : {t}1 Base_quickcheck.Generator.t
val quickcheck_observer : {t}1 Base_quickcheck.Observer.t
val quickcheck_shrinker : {t}1 Base_quickcheck.Shrinker.t
val gen_incl : {t}1 -> {t}1 -> {t}1 Base_quickcheck.Generator.t

gen_incl lower_bound upper_bound produces values between lower_bound and upper_bound, inclusive. It uses an ad hoc distribution that stresses boundary conditions more often than a uniform distribution, while still able to produce any value in the range. Raises if lower_bound > upper_bound.

val gen_uniform_incl : {t}1 -> {t}1 -> {t}1 Base_quickcheck.Generator.t

gen_uniform_incl lower_bound upper_bound produces a generator for values uniformly distributed between lower_bound and upper_bound, inclusive. Raises if lower_bound > upper_bound.

val gen_log_uniform_incl : {t}1 -> {t}1 -> {t}1 Base_quickcheck.Generator.t

gen_log_uniform_incl lower_bound upper_bound produces a generator for values between lower_bound and upper_bound, inclusive, where the number of bits used to represent the value is uniformly distributed. Raises if (lower_bound < 0) || (lower_bound > upper_bound).

val gen_log_incl : {t}1 -> {t}1 -> {t}1 Base_quickcheck.Generator.t

gen_log_incl lower_bound upper_bound is like gen_log_uniform_incl, but weighted slightly more in favor of generating lower_bound and upper_bound specifically.

include sig ... end
type nonrec t = {t}1
include Bin_prot.Binable.S_local with type t := t
include Bin_prot.Binable.S_local_only_functions with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_size_t__local : t Bin_prot.Size.sizer_local
val bin_write_t__local : t Bin_prot.Write.writer_local
val bin_shape_t : Bin_prot.Shape.t
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
OCaml

Innovation. Community. Security.