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
module Span : sig ... end
module Option : sig ... end

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

module Ofday : sig ... end

See Time.Ofday.

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
module Replace_polymorphic_compare : sig ... end
include Core_kernel.Comparator.S with type t := t with type comparator_witness := comparator_witness
module Map : sig ... end
module Set : sig ... end
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
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : sig ... end
module Zone : sig ... end
val epoch : t

Unix epoch (1970-01-01 00:00:00 UTC)

val min_value : t
val max_value : t
val now : unit -> t
val add : t -> Span.t -> t

overflows silently

val sub : t -> Span.t -> t

overflows silently

val diff : t -> t -> Span.t

overflows silently

val abs_diff : t -> t -> Span.t

overflows silently

val to_span_since_epoch : t -> Span.t
val of_span_since_epoch : Span.t -> t
val to_time : t -> Core_kernel.Time.t
val of_time : Core_kernel.Time.t -> t

not injective (rounds to nearest microsecond)

val to_string_fix_proto : [ `Utc | `Local ] -> t -> string
val of_string_fix_proto : [ `Utc | `Local ] -> string -> t
val to_string_abs : t -> zone:Core_kernel.Time.Zone.t -> string

See Time for documentation.

val of_string_abs : string -> t
val to_sec_string : t -> zone:Zone.t -> string
val to_int63_ns_since_epoch : t -> Core_kernel.Int63.t
val of_int63_ns_since_epoch : Core_kernel.Int63.t -> t
val to_int_ns_since_epoch : t -> int

Will raise on 32-bit platforms. Consider to_int63_ns_since_epoch instead.

val of_int_ns_since_epoch : int -> t
val to_filename_string : t -> zone:Zone.t -> string

See Time for documentation

val of_filename_string : string -> zone:Zone.t -> t
val next_multiple : ?can_equal_after:bool -> base:t -> after:t -> interval:Span.t -> unit -> t

See Core_kernel.Time_ns.

Overflows silently.

val of_date_ofday : zone:Zone.t -> Core_kernel.Date.t -> Ofday.t -> t
val to_ofday : t -> zone:Zone.t -> Ofday.t
val to_date : t -> zone:Zone.t -> Core_kernel.Date.t
val to_date_ofday : t -> zone:Zone.t -> Core_kernel.Date.t * Ofday.t
val occurrence : [ `First_after_or_at | `Last_before_or_at ] -> t -> ofday:Ofday.t -> zone:Core_kernel.Time.Zone.t -> t
val pause : Span.t -> unit

pause span sleeps for span time.

val interruptible_pause : Span.t -> [ `Ok | `Remaining of Span.t ]

interruptible_pause span sleeps for span time unless interrupted (e.g. by delivery of a signal), in which case the remaining unslept portion of time is returned.

val pause_forever : unit -> Core_kernel.Nothing.t

pause_forever sleeps indefinitely.

module Stable : sig ... end
val random : ?state:Core_kernel.Random.State.t -> unit -> t
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