Module Core_kernel__.Span

include Core_kernel__.Span_intf.Span with type underlying = float
include Core_kernel__.Span_intf.S
type underlying

Span.t represents a span of time (e.g. 7 minutes, 3 hours, 12.8 days). The span may be positive or negative.

type t = private underlying
include sig ... end
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (Core_kernel__.Import.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
val bin_shape_t : Bin_prot.Shape.t
val hash_fold_t : Base.Hash.state ‑> t ‑> Base.Hash.state
val hash : t ‑> Base.Hash.hash_value
val t_of_sexp : Base.Sexp.t ‑> t
val sexp_of_t : t ‑> Base.Sexp.t
include Core_kernel__.Std_internal.Comparable_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable.S
include Base__.Comparable_intf.Polymorphic_compare
include Base.Comparisons.Infix
type 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 ~compare: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

between t ~low ~high means low <= t <= high

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 t
type comparator_witness
include Base__.Comparable_intf.Validate with type t := t
type 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__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness
type t
include Core_kernel.Comparator.S with type t := t
type t
type comparator_witness
include Core_kernel.Comparable.With_zero with type t := t
type 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.

include Core_kernel__.Std_internal.Hashable_binable with type t := t
type 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__.Import.Pretty_printer.S with type t := t
type t
val pp : Base.Formatter.t ‑> t ‑> unit
include Core_kernel__.Std_internal.Robustly_comparable with type t := t
type 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_string : t ‑> Core_kernel__.Import.string

String converters and sexp converters allow for specifying of time spans in various units after a leading float (e.g. 45s, 3h, or 1d):

ms - milliseconds s - seconds m - minutes h - hours d - days

The outgoing conversion functions use these units as well, choosing the largest available type. For instance, if it's a bit greater than or equal to 1 hour, the span will be rendered in hours, (Time.to_string (Time.of_string "66m") = "1.1h").

As of Stable.V2, of_string and t_of_sexp also accept "us"=microseconds and "ns"=nanoseconds suffixes. Stable.V2 will produce these suffixes, but for compatibility with Stable.V1, ordinary to_string and sexp_of_t will not, for now. Once use of the new of_ family is more widespread, we will switch the to_ family to the more expressive format. In the meantime, you can get ns and us suffixes by using to_string_hum.

val of_string : Core_kernel__.Import.string ‑> t
values
val nanosecond : t
val microsecond : t
val millisecond : t
val second : t
val minute : t
val hour : t
val day : t
val robust_comparison_tolerance : t

10^-6 seconds, used in robustly comparable operators (<., >., =., ...) to determine equality

val zero : t
val create : ?⁠sign:Core_kernel.Sign.t ‑> ?⁠day:Core_kernel__.Import.int ‑> ?⁠hr:Core_kernel__.Import.int ‑> ?⁠min:Core_kernel__.Import.int ‑> ?⁠sec:Core_kernel__.Import.int ‑> ?⁠ms:Core_kernel__.Import.int ‑> ?⁠us:Core_kernel__.Import.int ‑> ?⁠ns:Core_kernel__.Import.int ‑> Core_kernel__.Import.unit ‑> t

create ?sign ?day ?hr ?min ?sec ?ms ?us ?ns () Create a span from the given parts. All parts are assumed to be positive (no checking is done by the function) and the sign of the final span is given by sign which is positive by default.

val to_parts : t ‑> Parts.t
converters
val of_ns : Core_kernel__.Import.float ‑> t
val of_us : Core_kernel__.Import.float ‑> t
val of_ms : Core_kernel__.Import.float ‑> t
val of_sec : Core_kernel__.Import.float ‑> t
val of_int_sec : Core_kernel__.Import.int ‑> t
val of_int32_seconds : Core_kernel.Int32.t ‑> t
val of_int63_seconds : Core_kernel.Int63.t ‑> t
val of_min : Core_kernel__.Import.float ‑> t
val of_hr : Core_kernel__.Import.float ‑> t
val of_day : Core_kernel__.Import.float ‑> t
val to_ns : t ‑> Core_kernel__.Import.float
val to_us : t ‑> Core_kernel__.Import.float
val to_ms : t ‑> Core_kernel__.Import.float
val to_sec : t ‑> Core_kernel__.Import.float
val to_min : t ‑> Core_kernel__.Import.float
val to_hr : t ‑> Core_kernel__.Import.float
val to_day : t ‑> Core_kernel__.Import.float
val to_int63_seconds_round_down_exn : t ‑> Core_kernel.Int63.t

to_int63_seconds_round_down_exn t returns the number of seconds represented by t, rounded down, raising if the result is not representable as an Int63.t.

val to_proportional_float : t ‑> Core_kernel__.Import.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.

Basic operations on spans
val (+) : t ‑> t ‑> t
val (-) : t ‑> t ‑> t
val abs : t ‑> t

absolute value

val neg : t ‑> t

negation

val scale : t ‑> Core_kernel__.Import.float ‑> t
val (/) : t ‑> Core_kernel__.Import.float ‑> t
val (//) : t ‑> t ‑> Core_kernel__.Import.float
val next : t ‑> t

next t return the next t (next t > t)

val prev : t ‑> t

prev t return the previous t (prev t < t)

val to_short_string : t ‑> Core_kernel__.Import.string

to_short_string t pretty-prints approximate time span using no more than five characters if the span is positive, and six if the span is negative. Examples

  • "4h" = 4 hours
  • "5m" = 5 minutes
  • "4s" = 4 seconds
  • "10ms" = 10 milliseconds

only the most significant denomination is shown.

val to_unit_of_time : t ‑> Core_kernel.Unit_of_time.t

to_unit_of_time t = Day if abs t >= day, Hour if abs t >= hour, and so on down to Microsecond if abs t >= microsecond, and Nanosecond otherwise.

val of_unit_of_time : Core_kernel.Unit_of_time.t ‑> t

of_unit_of_time unit_of_time produces a t representing the corresponding span.

val to_string_hum : ?⁠delimiter:Core_kernel__.Import.char ‑> ?⁠decimals:Core_kernel__.Import.int ‑> ?⁠align_decimal:Core_kernel__.Import.bool ‑> ?⁠unit_of_time:Core_kernel.Unit_of_time.t ‑> t ‑> Core_kernel__.Import.string

to_string_hum t ~delimiter ~decimals ~align_decimal ~unit_of_time formats t using the given unit of time, or the largest appropriate units if none is specified, among "d"=day, "h"=hour, "m"=minute, "s"=second, "ms"=millisecond, "us"=microsecond, or "ns"=nanosecond. The magnitude of the time span in the chosen unit is formatted by:

Float.to_string_hum ~delimiter ~decimals ~strip_zero:(not align_decimal)

If align_decimal is true, the single-character suffixes are padded with an extra space character. In combination with not stripping zeroes, this means that the decimal point will occur a fixed number of characters from the end of the string.

val randomize : t ‑> percent:Core_kernel.Percent.t ‑> t

randomize t ~percent returns a span +/- percent * original span. Percent must be between 0% and 100% inclusive, and must be positive.