package core

  1. Overview
  2. Docs
package core
Legend:
Library
Module
Module type
Parameter
Class
Class type
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
val bin_t : t Bin_prot.Type_class.t
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 : Ppx_sexp_conv_lib.Sexp.t -> t
include Core_kernel.Identifiable.S_common with type t := t
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
val of_string : string -> t
val to_string : t -> string
val pp : Base__.Formatter.t -> t -> unit
include Core_kernel.Comparable.S_binable with type t := t
include Base.Comparable.S 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
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
type comparator_witness
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
module Replace_polymorphic_compare : sig ... end
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
val hash_fold_t : Ppx_hash_lib.Std.Hash.state -> t -> Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Hash_queue : Core_kernel.Hash_queue.S with type Key.t = t
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
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.

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