package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type
include sig ... end
val typerep_of_t : t Typerep_lib.Std.Typerep.t
val typename_of_t : t Typerep_lib.Std.Typename.t
include Core_kernel.Identifiable with type t := t
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Base.Int.t -> 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
val bin_shape_t : Bin_prot.Shape.t
val t_of_sexp : Sexplib.Sexp.t -> t
include Core_kernel.Identifiable.S_common with type t := t
include sig ... end
val sexp_of_t : t -> Sexplib.Sexp.t
include Base.Stringable.S with type t := t
val of_string : string -> t
val to_string : t -> string
include Base.Pretty_printer.S with type t := t
val pp : Caml.Format.formatter -> t -> unit
include Core_kernel.Comparable.S_binable with type t := t
include Base.Comparable_intf.S with type t := t
include Base.Comparable_intf.Polymorphic_compare with type t := t
include Base.Comparisons.Infix with type t := t
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

compare t1 t2 returns 0 if t1 is equal to t2, a negative integer if t1 is less than t2, and a positive integer if t1 is greater than t2.

val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int

ascending is identical to compare. descending x y = ascending y x. These are intended to be mnemonic when used like List.sort ~cmp:ascending and List.sort ~cmp:descending, since they cause the list to be sorted in ascending or descending order, respectively.

val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
val clamp_exn : t -> min:t -> max:t -> t

clamp_exn t ~min ~max returns t', the closest value to t such that between t' ~low:min ~high:max is true.

Raises if not (min <= max).

val clamp : t -> min:t -> max:t -> t Base.Or_error.t
include Base.Comparator.S with type t := t
type comparator_witness
include Base.Comparable_intf.Validate with type t := t
val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check
val validate_bound : min:t Base.Maybe_bound.t -> max:t Base.Maybe_bound.t -> t Base.Validate.check
include Core_kernel.Comparator.S with type t := t with type comparator_witness := comparator_witness
include Core_kernel.Hashable.S_binable with type t := t
include sig ... end
val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state
val hash : t -> Base.Hash.hash_value
include Core_kernel.Comparable.With_zero with type t := t
val validate_positive : t Base.Validate.check
val validate_non_negative : t Base.Validate.check
val validate_negative : t Base.Validate.check
val validate_non_positive : t Base.Validate.check
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__.Sign0.t

Returns Neg, Zero, or Pos in a way consistent with the above functions.

module Parts : sig ... end

Similar to Time.Span.Parts.

val nanosecond : t
val microsecond : t
val millisecond : t
val second : t
val minute : t
val hour : t
val day : t
val of_ns : float -> t
val of_us : float -> t
val of_ms : float -> t
val of_sec : float -> t
val of_min : float -> t
val of_hr : float -> t
val of_day : float -> t
val to_ns : t -> float
val to_us : t -> float
val to_ms : t -> float
val to_sec : t -> float
val to_min : t -> float
val to_hr : t -> float
val to_day : t -> float
val of_int_us : int -> t
val of_int_ms : int -> t
val of_int_sec : int -> t
val to_int_us : t -> int
val to_int_ms : t -> int
val to_int_sec : t -> int
val zero : t
val min_value : t
val max_value : t
val (+) : t -> t -> t

overflows silently

val (-) : t -> t -> t

overflows silently

val abs : t -> t
val neg : t -> t
val scale : t -> float -> t
val scale_int : t -> int -> t

overflows silently

val div : t -> t -> Core_kernel.Int63.t
val (/) : t -> float -> t
val (//) : t -> t -> float
val create : ?sign:Core_kernel.Sign.t -> ?day:int -> ?hr:int -> ?min:int -> ?sec:int -> ?ms:int -> ?us:int -> ?ns:int -> unit -> t

Overflows silently.

val to_short_string : t -> string
val randomize : t -> percent:Core_kernel.Percent.t -> t
val to_parts : t -> Parts.t
val to_unit_of_time : t -> Core_kernel.Unit_of_time.t
val of_unit_of_time : Core_kernel.Unit_of_time.t -> t
val to_string_hum : ?delimiter:char -> ?decimals:int -> ?align_decimal:bool -> ?unit_of_time:Core_kernel.Unit_of_time.t -> t -> string

See Time.Span.to_string_hum.

Time.t is precise to approximately 0.24us in 2014. If to_span converts to the closest Time.Span.t, we have stability problems: converting back yields a different t, sometimes different enough to have a different external representation, because the conversion back and forth crosses a rounding boundary.

To stabilize conversion, we treat Time.t as having 1us precision: to_span and of_span both round to the nearest 1us.

Around 135y magnitudes, Time.Span.t no longer has 1us resolution. At that point, to_span and of_span raise.

The concern with stability is in part due to an earlier incarnation of Timing_wheel that had surprising behavior due to rounding of floating-point times. Timing_wheel was since re-implemented to use integer Time_ns, and to treat floating-point Times as equivalence classes according to the Time_ns that they round to. See Timing_wheel_float for details.

include Core_kernel.Robustly_comparable with type t := t
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 robustly_compare : t -> t -> int
val to_int63_ns : t -> Core_kernel.Int63.t

Fast, implemented as the identity function.

val of_int63_ns : Core_kernel.Int63.t -> t

Somewhat fast, implemented as a range check.

val to_int_ns : t -> int

Will raise on 32-bit platforms with spans corresponding to contemporary now. Consider to_int63_ns instead.

val of_int_ns : int -> t
val to_proportional_float : t -> float

The only condition to_proportional_float is supposed to satisfy is that for all t1, t2 : t: to_proportional_float t1 /. to_proportional_float t2 = t1 // t2.

module Stable : sig ... end
val random : ?state:Core_kernel.Random.State.t -> unit -> t
module Option : sig ... end

Span.Option.t is like Span.t option, except that the value is immediate on architectures where Int63.t is immediate. This module should mainly be used to avoid allocations.

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