# Module `Core_kernel.Date`

Date module.

`include Bin_prot.Binable.S with type t := t`

`include Bin_prot.Binable.S_only_functions with type t := t`

`val bin_size_t : t Bin_prot.Size.sizer`

`val bin_write_t : t Bin_prot.Write.writer`

`val bin_read_t : t Bin_prot.Read.reader`

`val __bin_read_t__ : (int -> t) Bin_prot.Read.reader`

This function only needs implementation if

`t`

exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant`t`

afterwards.

`val bin_shape_t : Bin_prot.Shape.t`

`val bin_writer_t : t Bin_prot.Type_class.writer`

`val bin_reader_t : t Bin_prot.Type_class.reader`

`val bin_t : t Bin_prot.Type_class.t`

`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`include Ppx_sexp_conv_lib.Sexpable.S with type t := t`

`val t_of_sexp : Sexplib0.Sexp.t -> t`

`val sexp_of_t : t -> Sexplib0.Sexp.t`

`include Typerep_lib.Typerepable.S with type t := t`

`val typerep_of_t : t Typerep_lib.Std_internal.Typerep.t`

`val typename_of_t : t Typerep_lib.Typename.t`

`include Core_kernel__.Std_internal.Hashable_binable with type t := t`

`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`

`val hash : t -> Base.Hash.hash_value`

`val hashable : t Hashtbl.Hashable.t`

`module Table : 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 the following 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`

`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`

`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`

`val comparator : (t, comparator_witness) Base.Comparator.comparator`

`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 : Core_kernel__.Comparable_intf.Polymorphic_compare with type t := t`

`include Core_kernel__.Comparable_intf.Map_and_set_binable with type t := t with type comparator_witness := comparator_witness`

`include Comparator.S with type t := t`

`val comparator : (t, comparator_witness) Comparator.comparator`

`module Map : Map.S_binable with type Key.t = t with type Key.comparator_witness = comparator_witness`

`module Set : Set.S_binable with type Elt.t = t with type Elt.comparator_witness = comparator_witness`

`include Core_kernel__.Import.Pretty_printer.S with type t := t`

`val pp : Base.Formatter.t -> 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

`val to_string_iso8601_basic : t -> Core_kernel__.Import.string`

YYYYMMDD

`val to_string_american : t -> Core_kernel__.Import.string`

MM/DD/YYYY

`val day : t -> Core_kernel__.Import.int`

`val month : t -> Month.t`

`val year : t -> Core_kernel__.Import.int`

`val day_of_week : t -> Day_of_week.t`

`val week_number_and_year : t -> Core_kernel__.Import.int * Core_kernel__.Import.int`

Week of the year, from 1 to 53, along with the week-numbering year to which the week belongs. The week-numbering year may not correspond to the calendar year in which the provided date occurs.

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. This means that dates near the end of the calendar year can have week number 1 and belong to the following week-numbering year, and dates near the beginning of the calendar year can have week number 52 or 53 and belong to the previous week-numbering year.

The triple (week-numbering year, week number, week day) uniquely identifies a particular date, which is not true if the calendar year is used instead.

`val week_number : t -> Core_kernel__.Import.int`

See

`week_number_and_year`

for the meaning of week number.

`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.In particular, this means adding

`x`

months and then adding`y`

months isn't the same as adding`x + y`

months, and in particular adding`x`

months and then`-x`

months won't always get you back where you were. *

`val add_years : t -> Core_kernel__.Import.int -> t`

`add_years t n`

has the same semantics as`add_months`

for adding years to Feb 29 of a leap year, i.e., when the addition results in a date in a non-leap year, the result will be Feb 28 of that 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`

.If you don't want to skip Saturday or Sunday, use

`add_days_skipping`

.

`val add_days_skipping : t -> skip:(t -> Core_kernel__.Import.bool) -> Core_kernel__.Import.int -> t`

`add_days_skipping t ~skip n`

adds`n`

days to`t`

, ignoring any date satisfying`skip`

, starting at the first date at or after`t`

that does not satisfy`skip`

. For example, if`skip t = true`

, then`add_days_skipping t ~skip 0 > t`

.`add_business_days`

and`add_weekdays`

are special cases of`add_days_skipping`

.

`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 days_in_month : year:Core_kernel__.Import.int -> month:Month.t -> Core_kernel__.Import.int`

`days_in_month ~year ~month`

returns the number of days in`month`

, using`year`

only if`month = Month.Feb`

to check if there is a leap year.

`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

`val unix_epoch : t`

The starting date of the UNIX epoch: 1970-01-01

`gen`

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

`include Core_kernel__.Std_internal.Quickcheckable with type t := t`

`val quickcheck_generator : t Base_quickcheck.Generator.t`

`val quickcheck_observer : t Base_quickcheck.Observer.t`

`val quickcheck_shrinker : t Base_quickcheck.Shrinker.t`

`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 Days : sig ... end with type date := t`

`Days`

provides a linear representation of dates that is optimized for arithmetic on the number of days between dates, rather than for representing year/month/day components. This module is intended for use only in performance-sensitive contexts where dates are manipulated more often than they are constructed or deconstructed; most clients should use the ordinary`t`

.

`module Stable : sig ... end`

`module O : sig ... end`

`module Private : sig ... end`

`val of_time : Core_kernel__.Time_float.t -> zone:Core_kernel__.Time_float.Zone.t -> t`

`val today : zone:Core_kernel__.Time_float.Zone.t -> t`