Module Core_kernel.Date

include Core_kernel__.Date_intf.Date
include module type of Core_kernel__.Date0 with type Date0.t := t
include Core_kernel__.Date0_intf.Date0
type t
include sig ... end
val t_of_sexp : Sexplib.Sexp.t ‑> t
val sexp_of_t : t ‑> Sexplib.Sexp.t
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
include Core_kernel__.Std_internal.Hashable_binable with type t := t
type t
val hash : t ‑> Core_kernel__.Import.int
module Table : Hashable.Hashtbl.S_binable with type key = t
module Hash_set : Hash_set.S_binable with type elt = t
module Hash_queue : Hash_queue.S with type Key.t = t

converts a string to a date, in formats: * m/d/y * y-m-d (* valid iso8601_extended *) * DD MMM YYYY * DDMMMYYYY * YYYYMMDD

include Core_kernel__.Std_internal.Stringable with type t := t
type t
val of_string : string ‑> t
val to_string : t ‑> string
include Core_kernel__.Std_internal.Comparable_binable with type t := t
include Core_kernel__.Comparable_intf.S_common
include Base.Comparable_intf.S
include Base.Comparable_intf.Polymorphic_compare
include Base.Polymorphic_compare_intf.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

-1 means "less than", 0 means "equal", 1 means "greater than", and other values should not be returned

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 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 Comparator.S with type t := t
type t
type comparator_witness
include Core_kernel__.Import.Pretty_printer.S with type t := t
type t
val pp : Caml.Format.formatter ‑> t ‑> unit
val create_exn : y:Core_kernel__.Import.int ‑> m:Month.t ‑> d:Core_kernel__.Import.int ‑> t

create_exn ~y ~m ~d creates the date specified in the arguments. Arguments are validated, and are not normalized in any way. So, days must be within the limits for the month in question, numbers cannot be negative, years must be fully specified, etc.

val of_string_iso8601_basic : Core_kernel__.Import.string ‑> pos:Core_kernel__.Import.int ‑> t

For details on this ISO format, see:

http://www.wikipedia.org/wiki/iso8601

YYYYMMDD

val to_string_iso8601_basic : t ‑> Core_kernel__.Import.string

YYYYMMDD

val to_string_american : t ‑> Core_kernel__.Import.string

MM/DD/YYYY

val month : t ‑> Month.t
val year : t ‑> Core_kernel__.Import.int
val day_of_week : t ‑> Day_of_week.t
val week_number : t ‑> Core_kernel__.Import.int

Week of the year, from 1 to 53. According to ISO 8601, weeks start on Monday, and the first week of a year is the week that contains the first Thursday of the year. Notice that this means that dates near the end of the year can have week number 1, and dates near the beginning of the year can have week number 52 or 53.

Warning: the triple (year, week number, week day) does not identify a date -- e.g. 2012-01-02 and 2012-12-31 are both Mondays of week 1. (However, if instead of the year, you use the year of the nearest Thursday, then it does work.)

val is_weekend : t ‑> Core_kernel__.Import.bool
val is_weekday : t ‑> Core_kernel__.Import.bool
val is_business_day : t ‑> is_holiday:(t ‑> Core_kernel__.Import.bool) ‑> Core_kernel__.Import.bool

Monday through Friday are business days, unless they're a holiday.

val add_days : t ‑> Core_kernel__.Import.int ‑> t

add_days t n adds n days to t and returns the resulting date.

val add_months : t ‑> Core_kernel__.Import.int ‑> t

add_months t n returns date with max days for the month if the date would be invalid. e.g. adding 1 month to Jan 30 results in Feb 28 due to Feb 30 being an invalid date, Feb 29 is returned in cases of leap year. *

val diff : t ‑> t ‑> Core_kernel__.Import.int

diff t1 t2 returns date t1 minus date t2 in days.

val diff_weekdays : t ‑> t ‑> Core_kernel__.Import.int

diff_weekdays t1 t2 returns the number of weekdays in the half-open interval [t2,t1) if t1 >= t2, and - diff_weekdays t2 t1 otherwise.

val diff_weekend_days : t ‑> t ‑> Core_kernel__.Import.int

diff_weekend_days t1 t2 returns the number of days that are weekend days in the half-open interval [t2,t1) if t1 >= t2, and - diff_weekend_days t2 t1 otherwise.

val add_weekdays : t ‑> Core_kernel__.Import.int ‑> t

add_weekdays t 0 returns the next weekday if t is a weekend and t otherwise. Unlike add_days this is done by looping over the count of days to be added (forward or backwards based on the sign), and is O(n) in the number of days to add. Beware, add_weekdays sat 1 or add_weekdays sun 1 both return the next tue, not the next mon. You may want to use following_weekday if you want the next following weekday, following_weekday (fri|sat|sun) would all return the next mon.

val add_business_days : t ‑> is_holiday:(t ‑> Core_kernel__.Import.bool) ‑> Core_kernel__.Import.int ‑> t

add_business_days t ~is_holiday n returns a business day even when n=0. add_business_days ~is_holiday:(fun _ -> false) ... is the same as add_weekdays.

val dates_between : min:t ‑> max:t ‑> t Core_kernel__.Import.list

the following returns a closed interval (endpoints included)

val business_dates_between : min:t ‑> max:t ‑> is_holiday:(t ‑> Core_kernel__.Import.bool) ‑> t Core_kernel__.Import.list
val weekdays_between : min:t ‑> max:t ‑> t Core_kernel__.Import.list
val previous_weekday : t ‑> t
val following_weekday : t ‑> t
val first_strictly_after : t ‑> on:Day_of_week.t ‑> t

first_strictly_after t ~on:day_of_week returns the first occurrence of day_of_week strictly after t.

val is_leap_year : year:Core_kernel__.Import.int ‑> Core_kernel__.Import.bool

is_leap_year ~year returns true if year is considered a leap year

gen generates dates between 1900-01-01 and 2100-01-01.

include Core_kernel__.Std_internal.Quickcheckable with type t := t
type 'a gen
type 'a obs
type 'a shr
type t
val gen : t gen
val obs : t obs
val shrinker : t shr
val gen_incl : t ‑> t ‑> t Quickcheck.Generator.t

gen_incl d1 d2 generates dates in the range between d1 and d2, inclusive, with the endpoints having higher weight than the rest. Raises if d1 > d2.

val gen_uniform_incl : t ‑> t ‑> t Quickcheck.Generator.t

gen_uniform_incl d1 d2 generates dates chosen uniformly in the range between d1 and d2, inclusive. Raises if d1 > d2.

module Stable : sig ... end
module O : sig ... end
val today : zone:Core_kernel__.Time_float.Zone.t ‑> t