Core.Date
SourceDate module.
include Bin_prot.Binable.S_local with type t := t
include Bin_prot.Binable.S_local_only_functions with type t := t
include Bin_prot.Binable.S_only_functions with type t := t
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.
include Ppx_hash_lib.Hashable.S with type t := t
include Interfaces.Hashable_binable with type t := t
converts a string to a date in the following formats:
include Interfaces.Comparable_binable with type t := t
include Base.Comparable.S with type t := t
include Base.Comparisons.S with type t := t
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
.
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.
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)
.
include Base.Comparator.S with type t := t
include Comparator.S
with type t := t
with type comparator_witness := comparator_witness
val comparator : (t, comparator_witness) Base.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 Diffable.S_atomic with type t := t
include Base.Pretty_printer.S with type t := 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.
For details on this ISO format, see:
http://www.wikipedia.org/wiki/iso8601
YYYYMMDD
MM/DD/YYYY
Only accurate after 1752-09
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.
See week_number_and_year
for the meaning of week number.
is_weekend
and is_weekday
treat Saturday and Sunday as the weekend, and Monday through Friday as weekdays.
Caveat: Not all cultures, countries, or businesses conform to this particular cycle of weekend / weekday.
Monday through Friday are business days, unless they're a holiday.
See the caveat on is_weekend
about varying weekend/weekday cycles.
add_days t n
adds n days to t
and returns the resulting date.
Inaccurate when crossing 1752-09.
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. *
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.
diff t1 t2
returns date t1
minus date t2
in days.
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.
See the caveat on is_weekend
about varying weekend/weekday cycles.
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.
See the caveat on is_weekend
about varying weekend/weekday cycles.
First rounds the given date backward to the previous weekday, if it is not already a weekday. Then advances by the given number of weekdays, which may be negative.
See the caveat on is_weekend
about varying weekend/weekday cycles.
First rounds the given date forward to the next weekday, if it is not already a weekday. Then advances by the given number of weekdays, which may be negative.
See the caveat on is_weekend
about varying weekend/weekday cycles.
val add_business_days_rounding_backward :
t ->
is_holiday:(t -> Base.Bool.t) ->
Base.Int.t ->
t
First rounds the given date backward to the previous business day, i.e. weekday not satisfying is_holiday
, if it is not already a business day. Then advances by the given number of business days, which may be negative.
See the caveat on is_weekend
about varying weekend/weekday cycles.
val add_business_days_rounding_forward :
t ->
is_holiday:(t -> Base.Bool.t) ->
Base.Int.t ->
t
First rounds the given date forward to the next business day, i.e. weekday not satisfying is_holiday
, if it is not already a business day. Then advances by the given number of business days, which may be negative.
See the caveat on is_weekend
about varying weekend/weekday cycles.
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
.
See the caveat on is_weekend
about varying weekend/weekday cycles.
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
.
See the caveat on is_weekend
about varying weekend/weekday cycles.
val add_business_days_rounding_in_direction_of_step :
t ->
is_holiday:(t -> Base.Bool.t) ->
Base.Int.t ->
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
.
the following returns a closed interval (endpoints included)
business_dates_between ~min ~max ~is_holiday
returns the list of dates between min
and max
, inclusive, for which is_business_day ~is_holiday
.
See the caveat on is_weekend
about varying weekend/weekday cycles.
See the caveat on is_weekend
about varying weekend/weekday cycles.
first_strictly_after t ~on:day_of_week
returns the first occurrence of day_of_week
strictly after t
.
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.
Incorrect for September 1752.
is_leap_year ~year
returns true if year
is considered a leap year
gen
generates dates between 1900-01-01 and 2100-01-01.
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
.
gen_uniform_incl d1 d2
generates dates chosen uniformly in the range between d1
and d2
, inclusive. Raises if d1 > d2
.
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
.
Deprecations