package bonsai

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

Id_gen builds a component which generates unique identifiers by starting at 0 and incrementing by one every time that the effect is called.

The functor is parameteraized on the size of integer (int vs int63 vs int64), and it's also a generative functor, so invoking the functor multiple times times will mint new types.

I explicitly disassociate the input T from the output T because otherwise the benefits of the generative functor would be gone.

Parameters

Signature

include Core.Int_intf.S
include Base.Int.S
type t
val t_sexp_grammar : t Sexplib0.Sexp_grammar.t
val of_float : float -> t
val to_float : t -> float
val of_int_exn : int -> t
val to_int_exn : t -> int
type comparator_witness
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
val sign : t -> Base__.Comparable_intf.Sign.t
val invariant : t Base__.Invariant_intf.inv
val to_string_hum : ?delimiter:char -> t -> string
val zero : t
val one : t
val minus_one : t
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (**) : t -> t -> t
val neg : t -> t
val (~-) : t -> t
val (/%) : t -> t -> t
val (%) : t -> t -> t
val (/) : t -> t -> t
val rem : t -> t -> t
val (//) : t -> t -> float
val (land) : t -> t -> t
val (lor) : t -> t -> t
val (lxor) : t -> t -> t
val lnot : t -> t
val (lsl) : t -> int -> t
val (asr) : t -> int -> t
val round : ?dir:[ `Down | `Nearest | `Up | `Zero ] -> t -> to_multiple_of:t -> t
val round_towards_zero : t -> to_multiple_of:t -> t
val round_down : t -> to_multiple_of:t -> t
val round_up : t -> to_multiple_of:t -> t
val round_nearest : t -> to_multiple_of:t -> t
val abs : t -> t
val succ : t -> t
val pred : t -> t
val pow : t -> t -> t
val bit_and : t -> t -> t
val bit_or : t -> t -> t
val bit_xor : t -> t -> t
val bit_not : t -> t
val popcount : t -> int
val shift_left : t -> int -> t
val shift_right : t -> int -> t
val decr : t Base__.Import.ref -> unit
val incr : t Base__.Import.ref -> unit
val of_int32_exn : int32 -> t
val to_int32_exn : t -> int32
val of_int64_exn : int64 -> t
val to_int64 : t -> int64
val of_nativeint_exn : nativeint -> t
val to_nativeint_exn : t -> nativeint
val of_float_unchecked : float -> t
val num_bits : int
val max_value : t
val min_value : t
val (lsr) : t -> int -> t
val shift_right_logical : t -> int -> t
val ceil_pow2 : t -> t
val floor_pow2 : t -> t
val ceil_log2 : t -> int
val floor_log2 : t -> int
val is_pow2 : t -> bool
val clz : t -> int
val ctz : t -> int
module O : sig ... end
include Core.Int_intf.Extension with type t := t with type comparator_witness := comparator_witness
include Bin_prot.Binable.S with type t := t
include Typerep_lib.Typerepable.S with type t := t
val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t
val typename_of_t : t Typerep_lib.Typename.t
include Core.Int_intf.Hexable with type t := t
module Hex : sig ... end
include Base.Int.Hexable with type t := t and module Hex := Hex
include Core.Identifiable.S with type t := t with type comparator_witness := comparator_witness
include Bin_prot.Binable.S 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
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
val bin_t : t Bin_prot.Type_class.t
include Ppx_hash_lib.Hashable.S with type t := t
include Sexplib0.Sexpable.S with type t := t
val t_of_sexp : Sexplib0__.Sexp.t -> t
include Ppx_compare_lib.Comparable.S with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val sexp_of_t : t -> Sexplib0.Sexp.t
val of_string : string -> t
val to_string : t -> string
val pp : Base__.Formatter.t -> t -> unit
include Core.Comparable.S_binable with type t := t with type comparator_witness := comparator_witness
include Base.Comparable.S with type t := t with type comparator_witness := comparator_witness
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (=) : t -> t -> bool
val (>) : t -> t -> bool
val (<) : t -> t -> bool
val (<>) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t
val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
module Replace_polymorphic_compare : sig ... end
include Core.Comparator.S with type t := t with type comparator_witness := comparator_witness
include Core.Hashable.S_binable with type t := t
include Ppx_hash_lib.Hashable.S with type t := t
val hash_fold_t : t Base__Ppx_hash_lib.hash_fold
val hash : t -> Base__Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core__.Hashtbl.Hashable.t
module Table : Core.Hashtbl.S_binable with type key = t
module Hash_set : Core.Hash_set.S_binable with type elt = t
module Hash_queue : Core.Hash_queue.S with type key = t
include Core.Comparable.Validate_with_zero with type t := t
val validate_lbound : min:t Core.Maybe_bound.t -> t Validate.check
val validate_ubound : max:t Core.Maybe_bound.t -> t Validate.check
val validate_bound : min:t Core.Maybe_bound.t -> max:t Core.Maybe_bound.t -> t Validate.check
val validate_positive : t Validate.check
val validate_non_negative : t Validate.check
val validate_negative : t Validate.check
val validate_non_positive : t Validate.check
include Core.Quickcheckable.S_int with type t := t
include Core.Quickcheck_intf.S_range with type t := t
include Core.Quickcheck_intf.S with type t := t
val quickcheck_generator : t Base_quickcheck.Generator.t
val quickcheck_observer : t Base_quickcheck.Observer.t
val quickcheck_shrinker : t Base_quickcheck.Shrinker.t
val gen_incl : t -> t -> t 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 -> t -> t 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 -> t -> t 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 -> t -> t 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.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct