Struct chrono::naive::NaiveDate

source ·
pub struct NaiveDate { /* private fields */ }
Expand description

ISO 8601 calendar date without timezone. Allows for every proleptic Gregorian date from Jan 1, 262145 BCE to Dec 31, 262143 CE. Also supports the conversion from ISO 8601 ordinal and week date.

§Calendar Date

The ISO 8601 calendar date follows the proleptic Gregorian calendar. It is like a normal civil calendar but note some slight differences:

  • Dates before the Gregorian calendar’s inception in 1582 are defined via the extrapolation. Be careful, as historical dates are often noted in the Julian calendar and others and the transition to Gregorian may differ across countries (as late as early 20C).

    (Some example: Both Shakespeare from Britain and Cervantes from Spain seemingly died on the same calendar date—April 23, 1616—but in the different calendar. Britain used the Julian calendar at that time, so Shakespeare’s death is later.)

  • ISO 8601 calendars has the year 0, which is 1 BCE (a year before 1 CE). If you need a typical BCE/BC and CE/AD notation for year numbers, use the Datelike::year_ce method.

§Week Date

The ISO 8601 week date is a triple of year number, week number and day of the week with the following rules:

  • A week consists of Monday through Sunday, and is always numbered within some year. The week number ranges from 1 to 52 or 53 depending on the year.

  • The week 1 of given year is defined as the first week containing January 4 of that year, or equivalently, the first week containing four or more days in that year.

  • The year number in the week date may not correspond to the actual Gregorian year. For example, January 3, 2016 (Sunday) was on the last (53rd) week of 2015.

Chrono’s date types default to the ISO 8601 calendar date, but Datelike::iso_week and Datelike::weekday methods can be used to get the corresponding week date.

§Ordinal Date

The ISO 8601 ordinal date is a pair of year number and day of the year (“ordinal”). The ordinal number ranges from 1 to 365 or 366 depending on the year. The year number is the same as that of the calendar date.

This is currently the internal format of Chrono’s date types.

Implementations§

source§

impl NaiveDate

source

pub fn from_ymd(year: i32, month: u32, day: u32) -> NaiveDate

👎Deprecated since 0.4.23: use from_ymd_opt() instead

Makes a new NaiveDate from the calendar date (year, month and day).

Panics on the out-of-range date, invalid month and/or day.

source

pub fn from_ymd_opt(year: i32, month: u32, day: u32) -> Option<NaiveDate>

Makes a new NaiveDate from the calendar date (year, month and day).

Returns None on the out-of-range date, invalid month and/or day.

§Example
use chrono::NaiveDate;

let from_ymd_opt = NaiveDate::from_ymd_opt;

assert!(from_ymd_opt(2015, 3, 14).is_some());
assert!(from_ymd_opt(2015, 0, 14).is_none());
assert!(from_ymd_opt(2015, 2, 29).is_none());
assert!(from_ymd_opt(-4, 2, 29).is_some()); // 5 BCE is a leap year
assert!(from_ymd_opt(400000, 1, 1).is_none());
assert!(from_ymd_opt(-400000, 1, 1).is_none());
source

pub fn from_yo(year: i32, ordinal: u32) -> NaiveDate

👎Deprecated since 0.4.23: use from_yo_opt() instead

Makes a new NaiveDate from the ordinal date (year and day of the year).

Panics on the out-of-range date and/or invalid day of year.

source

pub fn from_yo_opt(year: i32, ordinal: u32) -> Option<NaiveDate>

Makes a new NaiveDate from the ordinal date (year and day of the year).

Returns None on the out-of-range date and/or invalid day of year.

§Example
use chrono::NaiveDate;

let from_yo_opt = NaiveDate::from_yo_opt;

assert!(from_yo_opt(2015, 100).is_some());
assert!(from_yo_opt(2015, 0).is_none());
assert!(from_yo_opt(2015, 365).is_some());
assert!(from_yo_opt(2015, 366).is_none());
assert!(from_yo_opt(-4, 366).is_some()); // 5 BCE is a leap year
assert!(from_yo_opt(400000, 1).is_none());
assert!(from_yo_opt(-400000, 1).is_none());
source

pub fn from_isoywd(year: i32, week: u32, weekday: Weekday) -> NaiveDate

👎Deprecated since 0.4.23: use from_isoywd_opt() instead

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Panics on the out-of-range date and/or invalid week number.

source

pub fn from_isoywd_opt( year: i32, week: u32, weekday: Weekday ) -> Option<NaiveDate>

Makes a new NaiveDate from the ISO week date (year, week number and day of the week). The resulting NaiveDate may have a different year from the input year.

Returns None on the out-of-range date and/or invalid week number.

§Example
use chrono::{NaiveDate, Weekday};

let from_ymd = NaiveDate::from_ymd;
let from_isoywd_opt = NaiveDate::from_isoywd_opt;

assert_eq!(from_isoywd_opt(2015, 0, Weekday::Sun), None);
assert_eq!(from_isoywd_opt(2015, 10, Weekday::Sun), Some(from_ymd(2015, 3, 8)));
assert_eq!(from_isoywd_opt(2015, 30, Weekday::Mon), Some(from_ymd(2015, 7, 20)));
assert_eq!(from_isoywd_opt(2015, 60, Weekday::Mon), None);

assert_eq!(from_isoywd_opt(400000, 10, Weekday::Fri), None);
assert_eq!(from_isoywd_opt(-400000, 10, Weekday::Sat), None);

The year number of ISO week date may differ from that of the calendar date.

//           Mo Tu We Th Fr Sa Su
// 2014-W52  22 23 24 25 26 27 28    has 4+ days of new year,
// 2015-W01  29 30 31  1  2  3  4 <- so this is the first week
assert_eq!(from_isoywd_opt(2014, 52, Weekday::Sun), Some(from_ymd(2014, 12, 28)));
assert_eq!(from_isoywd_opt(2014, 53, Weekday::Mon), None);
assert_eq!(from_isoywd_opt(2015, 1, Weekday::Mon), Some(from_ymd(2014, 12, 29)));

// 2015-W52  21 22 23 24 25 26 27    has 4+ days of old year,
// 2015-W53  28 29 30 31  1  2  3 <- so this is the last week
// 2016-W01   4  5  6  7  8  9 10
assert_eq!(from_isoywd_opt(2015, 52, Weekday::Sun), Some(from_ymd(2015, 12, 27)));
assert_eq!(from_isoywd_opt(2015, 53, Weekday::Sun), Some(from_ymd(2016, 1, 3)));
assert_eq!(from_isoywd_opt(2015, 54, Weekday::Mon), None);
assert_eq!(from_isoywd_opt(2016, 1, Weekday::Mon), Some(from_ymd(2016, 1, 4)));
source

pub fn from_num_days_from_ce(days: i32) -> NaiveDate

👎Deprecated since 0.4.23: use from_num_days_from_ce_opt() instead

Makes a new NaiveDate from a day’s number in the proleptic Gregorian calendar, with January 1, 1 being day 1.

Panics if the date is out of range.

source

pub fn from_num_days_from_ce_opt(days: i32) -> Option<NaiveDate>

Makes a new NaiveDate from a day’s number in the proleptic Gregorian calendar, with January 1, 1 being day 1.

Returns None if the date is out of range.

§Example
use chrono::NaiveDate;

let from_ndays_opt = NaiveDate::from_num_days_from_ce_opt;
let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

assert_eq!(from_ndays_opt(730_000),      Some(from_ymd(1999, 9, 3)));
assert_eq!(from_ndays_opt(1),            Some(from_ymd(1, 1, 1)));
assert_eq!(from_ndays_opt(0),            Some(from_ymd(0, 12, 31)));
assert_eq!(from_ndays_opt(-1),           Some(from_ymd(0, 12, 30)));
assert_eq!(from_ndays_opt(100_000_000),  None);
assert_eq!(from_ndays_opt(-100_000_000), None);
source

pub fn from_weekday_of_month( year: i32, month: u32, weekday: Weekday, n: u8 ) -> NaiveDate

👎Deprecated since 0.4.23: use from_weekday_of_month_opt() instead

Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week since the beginning of the given month. For instance, if you want the 2nd Friday of March 2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2).

§Panics

The resulting NaiveDate is guaranteed to be in month. If n is larger than the number of weekday in month (eg. the 6th Friday of March 2017) then this function will panic.

n is 1-indexed. Passing n=0 will cause a panic.

source

pub fn from_weekday_of_month_opt( year: i32, month: u32, weekday: Weekday, n: u8 ) -> Option<NaiveDate>

Makes a new NaiveDate by counting the number of occurrences of a particular day-of-week since the beginning of the given month. For instance, if you want the 2nd Friday of March 2017, you would use NaiveDate::from_weekday_of_month(2017, 3, Weekday::Fri, 2). n is 1-indexed.

use chrono::{NaiveDate, Weekday};
assert_eq!(NaiveDate::from_weekday_of_month_opt(2017, 3, Weekday::Fri, 2),
           NaiveDate::from_ymd_opt(2017, 3, 10))

Returns None if n out-of-range; ie. if n is larger than the number of weekday in month (eg. the 6th Friday of March 2017), or if n == 0.

source

pub fn parse_from_str(s: &str, fmt: &str) -> ParseResult<NaiveDate>

Parses a string with the specified format string and returns a new NaiveDate. See the format::strftime module on the supported escape sequences.

§Example
use chrono::NaiveDate;

let parse_from_str = NaiveDate::parse_from_str;

assert_eq!(parse_from_str("2015-09-05", "%Y-%m-%d"),
           Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()));
assert_eq!(parse_from_str("5sep2015", "%d%b%Y"),
           Ok(NaiveDate::from_ymd_opt(2015, 9, 5).unwrap()));

Time and offset is ignored for the purpose of parsing.

assert_eq!(parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
           Ok(NaiveDate::from_ymd_opt(2014, 5, 17).unwrap()));

Out-of-bound dates or insufficient fields are errors.

assert!(parse_from_str("2015/9", "%Y/%m").is_err());
assert!(parse_from_str("2015/9/31", "%Y/%m/%d").is_err());

All parsed fields should be consistent to each other, otherwise it’s an error.

assert!(parse_from_str("Sat, 09 Aug 2013", "%a, %d %b %Y").is_err());
source

pub fn checked_add_months(self, months: Months) -> Option<Self>

Add a duration in Months to the date

If the day would be out of range for the resulting month, use the last day for that month.

Returns None if the resulting date would be out of range.

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_add_months(Months::new(6)),
    Some(NaiveDate::from_ymd_opt(2022, 8, 20).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_months(Months::new(2)),
    Some(NaiveDate::from_ymd_opt(2022, 9, 30).unwrap())
);
source

pub fn checked_sub_months(self, months: Months) -> Option<Self>

Subtract a duration in Months from the date

If the day would be out of range for the resulting month, use the last day for that month.

Returns None if the resulting date would be out of range.

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_months(Months::new(6)),
    Some(NaiveDate::from_ymd_opt(2021, 8, 20).unwrap())
);

assert_eq!(
    NaiveDate::from_ymd_opt(2014, 1, 1).unwrap()
        .checked_sub_months(Months::new(core::i32::MAX as u32 + 1)),
    None
);
source

pub fn checked_add_days(self, days: Days) -> Option<Self>

Add a duration in Days to the date

Returns None if the resulting date would be out of range.

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_add_days(Days::new(9)),
    Some(NaiveDate::from_ymd_opt(2022, 3, 1).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_days(Days::new(2)),
    Some(NaiveDate::from_ymd_opt(2022, 8, 2).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 7, 31).unwrap().checked_add_days(Days::new(1000000000000)),
    None
);
source

pub fn checked_sub_days(self, days: Days) -> Option<Self>

Subtract a duration in Days from the date

Returns None if the resulting date would be out of range.

assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_days(Days::new(6)),
    Some(NaiveDate::from_ymd_opt(2022, 2, 14).unwrap())
);
assert_eq!(
    NaiveDate::from_ymd_opt(2022, 2, 20).unwrap().checked_sub_days(Days::new(1000000000000)),
    None
);
source

pub const fn and_time(&self, time: NaiveTime) -> NaiveDateTime

Makes a new NaiveDateTime from the current date and given NaiveTime.

§Example
use chrono::{NaiveDate, NaiveTime, NaiveDateTime};

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
let t = NaiveTime::from_hms_milli_opt(12, 34, 56, 789).unwrap();

let dt: NaiveDateTime = d.and_time(t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);
source

pub fn and_hms(&self, hour: u32, min: u32, sec: u32) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_* methods with a subsecond parameter instead.

Panics on invalid hour, minute and/or second.

source

pub fn and_hms_opt( &self, hour: u32, min: u32, sec: u32 ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute and second.

No leap second is allowed here; use NaiveDate::and_hms_*_opt methods with a subsecond parameter instead.

Returns None on invalid hour, minute and/or second.

§Example
use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_opt(12, 34, 56).is_some());
assert!(d.and_hms_opt(12, 34, 60).is_none()); // use `and_hms_milli_opt` instead
assert!(d.and_hms_opt(12, 60, 56).is_none());
assert!(d.and_hms_opt(24, 34, 56).is_none());
source

pub fn and_hms_milli( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_milli_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part can exceed 1,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or millisecond.

source

pub fn and_hms_milli_opt( &self, hour: u32, min: u32, sec: u32, milli: u32 ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and millisecond.

The millisecond part can exceed 1,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or millisecond.

§Example
use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_milli_opt(12, 34, 56,   789).is_some());
assert!(d.and_hms_milli_opt(12, 34, 59, 1_789).is_some()); // leap second
assert!(d.and_hms_milli_opt(12, 34, 59, 2_789).is_none());
assert!(d.and_hms_milli_opt(12, 34, 60,   789).is_none());
assert!(d.and_hms_milli_opt(12, 60, 56,   789).is_none());
assert!(d.and_hms_milli_opt(24, 34, 56,   789).is_none());
source

pub fn and_hms_micro( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_micro_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part can exceed 1,000,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or microsecond.

§Example
use chrono::{NaiveDate, NaiveDateTime, Datelike, Timelike, Weekday};

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();

let dt: NaiveDateTime = d.and_hms_micro(12, 34, 56, 789_012);
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);
source

pub fn and_hms_micro_opt( &self, hour: u32, min: u32, sec: u32, micro: u32 ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and microsecond.

The microsecond part can exceed 1,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or microsecond.

§Example
use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_micro_opt(12, 34, 56,   789_012).is_some());
assert!(d.and_hms_micro_opt(12, 34, 59, 1_789_012).is_some()); // leap second
assert!(d.and_hms_micro_opt(12, 34, 59, 2_789_012).is_none());
assert!(d.and_hms_micro_opt(12, 34, 60,   789_012).is_none());
assert!(d.and_hms_micro_opt(12, 60, 56,   789_012).is_none());
assert!(d.and_hms_micro_opt(24, 34, 56,   789_012).is_none());
source

pub fn and_hms_nano( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> NaiveDateTime

👎Deprecated since 0.4.23: use and_hms_nano_opt() instead

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.

Panics on invalid hour, minute, second and/or nanosecond.

source

pub fn and_hms_nano_opt( &self, hour: u32, min: u32, sec: u32, nano: u32 ) -> Option<NaiveDateTime>

Makes a new NaiveDateTime from the current date, hour, minute, second and nanosecond.

The nanosecond part can exceed 1,000,000,000 in order to represent the leap second.

Returns None on invalid hour, minute, second and/or nanosecond.

§Example
use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();
assert!(d.and_hms_nano_opt(12, 34, 56,   789_012_345).is_some());
assert!(d.and_hms_nano_opt(12, 34, 59, 1_789_012_345).is_some()); // leap second
assert!(d.and_hms_nano_opt(12, 34, 59, 2_789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 34, 60,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(12, 60, 56,   789_012_345).is_none());
assert!(d.and_hms_nano_opt(24, 34, 56,   789_012_345).is_none());
source

pub fn succ(&self) -> NaiveDate

👎Deprecated since 0.4.23: use succ_opt() instead

Makes a new NaiveDate for the next calendar date.

Panics when self is the last representable date.

source

pub fn succ_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the next calendar date.

Returns None when self is the last representable date.

§Example
use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd_opt(2015, 6, 3).unwrap().succ_opt(),
           Some(NaiveDate::from_ymd_opt(2015, 6, 4).unwrap()));
assert_eq!(NaiveDate::MAX.succ_opt(), None);
source

pub fn pred(&self) -> NaiveDate

👎Deprecated since 0.4.23: use pred_opt() instead

Makes a new NaiveDate for the previous calendar date.

Panics when self is the first representable date.

source

pub fn pred_opt(&self) -> Option<NaiveDate>

Makes a new NaiveDate for the previous calendar date.

Returns None when self is the first representable date.

§Example
use chrono::NaiveDate;

assert_eq!(NaiveDate::from_ymd_opt(2015, 6, 3).unwrap().pred_opt(),
           Some(NaiveDate::from_ymd_opt(2015, 6, 2).unwrap()));
assert_eq!(NaiveDate::MIN.pred_opt(), None);
source

pub fn checked_add_signed(self, rhs: OldDuration) -> Option<NaiveDate>

Adds the days part of given Duration to the current date.

Returns None when it will result in overflow.

§Example
use chrono::{Duration, NaiveDate};

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.checked_add_signed(Duration::days(40)),
           Some(NaiveDate::from_ymd_opt(2015, 10, 15).unwrap()));
assert_eq!(d.checked_add_signed(Duration::days(-40)),
           Some(NaiveDate::from_ymd_opt(2015, 7, 27).unwrap()));
assert_eq!(d.checked_add_signed(Duration::days(1_000_000_000)), None);
assert_eq!(d.checked_add_signed(Duration::days(-1_000_000_000)), None);
assert_eq!(NaiveDate::MAX.checked_add_signed(Duration::days(1)), None);
source

pub fn checked_sub_signed(self, rhs: OldDuration) -> Option<NaiveDate>

Subtracts the days part of given Duration from the current date.

Returns None when it will result in overflow.

§Example
use chrono::{Duration, NaiveDate};

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.checked_sub_signed(Duration::days(40)),
           Some(NaiveDate::from_ymd_opt(2015, 7, 27).unwrap()));
assert_eq!(d.checked_sub_signed(Duration::days(-40)),
           Some(NaiveDate::from_ymd_opt(2015, 10, 15).unwrap()));
assert_eq!(d.checked_sub_signed(Duration::days(1_000_000_000)), None);
assert_eq!(d.checked_sub_signed(Duration::days(-1_000_000_000)), None);
assert_eq!(NaiveDate::MIN.checked_sub_signed(Duration::days(1)), None);
source

pub fn signed_duration_since(self, rhs: NaiveDate) -> OldDuration

Subtracts another NaiveDate from the current date. Returns a Duration of integral numbers.

This does not overflow or underflow at all, as all possible output fits in the range of Duration.

§Example
use chrono::{Duration, NaiveDate};

let from_ymd = NaiveDate::from_ymd;
let since = NaiveDate::signed_duration_since;

assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 1)), Duration::zero());
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 12, 31)), Duration::days(1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2014, 1, 2)), Duration::days(-1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 9, 23)), Duration::days(100));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2013, 1, 1)), Duration::days(365));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(2010, 1, 1)), Duration::days(365*4 + 1));
assert_eq!(since(from_ymd(2014, 1, 1), from_ymd(1614, 1, 1)), Duration::days(365*400 + 97));
source

pub fn years_since(&self, base: Self) -> Option<u32>

Returns the number of whole years from the given base until self.

source

pub fn format_with_items<'a, I, B>(&self, items: I) -> DelayedFormat<I>
where I: Iterator<Item = B> + Clone, B: Borrow<Item<'a>>,

Formats the date with the specified formatting items. Otherwise it is the same as the ordinary format method.

The Iterator of items should be Cloneable, since the resulting DelayedFormat value may be formatted multiple times.

§Example
use chrono::NaiveDate;
use chrono::format::strftime::StrftimeItems;

let fmt = StrftimeItems::new("%Y-%m-%d");
let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.format_with_items(fmt.clone()).to_string(), "2015-09-05");
assert_eq!(d.format("%Y-%m-%d").to_string(),             "2015-09-05");

The resulting DelayedFormat can be formatted directly via the Display trait.

assert_eq!(format!("{}", d.format_with_items(fmt)), "2015-09-05");
source

pub fn format<'a>(&self, fmt: &'a str) -> DelayedFormat<StrftimeItems<'a>>

Formats the date with the specified format string. See the format::strftime module on the supported escape sequences.

This returns a DelayedFormat, which gets converted to a string only when actual formatting happens. You may use the to_string method to get a String, or just feed it into print! and other formatting macros. (In this way it avoids the redundant memory allocation.)

A wrong format string does not issue an error immediately. Rather, converting or formatting the DelayedFormat fails. You are recommended to immediately use DelayedFormat for this reason.

§Example
use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 9, 5).unwrap();
assert_eq!(d.format("%Y-%m-%d").to_string(), "2015-09-05");
assert_eq!(d.format("%A, %-d %B, %C%y").to_string(), "Saturday, 5 September, 2015");

The resulting DelayedFormat can be formatted directly via the Display trait.

assert_eq!(format!("{}", d.format("%Y-%m-%d")), "2015-09-05");
assert_eq!(format!("{}", d.format("%A, %-d %B, %C%y")), "Saturday, 5 September, 2015");
source

pub const fn iter_days(&self) -> NaiveDateDaysIterator

Returns an iterator that steps by days across all representable dates.

§Example

let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 28).unwrap(),
    NaiveDate::from_ymd_opt(2016, 2, 29).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 1).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_days().take(4).enumerate() {
   assert_eq!(d, expected[idx]);
   count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 1).unwrap().iter_days().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}
source

pub const fn iter_weeks(&self) -> NaiveDateWeeksIterator

Returns an iterator that steps by weeks across all representable dates.

§Example

let expected = [
    NaiveDate::from_ymd_opt(2016, 2, 27).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 5).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 12).unwrap(),
    NaiveDate::from_ymd_opt(2016, 3, 19).unwrap(),
];

let mut count = 0;
for (idx, d) in NaiveDate::from_ymd_opt(2016, 2, 27).unwrap().iter_weeks().take(4).enumerate() {
   assert_eq!(d, expected[idx]);
   count += 1;
}
assert_eq!(count, 4);

for d in NaiveDate::from_ymd_opt(2016, 3, 19).unwrap().iter_weeks().rev().take(4) {
    count -= 1;
    assert_eq!(d, expected[count]);
}
source

pub const fn week(&self, start: Weekday) -> NaiveWeek

Returns the NaiveWeek that the date belongs to, starting with the Weekday specified.

source

pub const MIN: NaiveDate = _

The minimum possible NaiveDate (January 1, 262145 BCE).

source

pub const MAX: NaiveDate = _

The maximum possible NaiveDate (December 31, 262143 CE).

Trait Implementations§

source§

impl Add<Days> for NaiveDate

§

type Output = NaiveDate

The resulting type after applying the + operator.
source§

fn add(self, days: Days) -> Self::Output

Performs the + operation. Read more
source§

impl Add<Duration> for NaiveDate

An addition of Duration to NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero().

Panics on underflow or overflow. Use NaiveDate::checked_add_signed to detect that.

§Example

use chrono::{Duration, NaiveDate};

let from_ymd = NaiveDate::from_ymd;

assert_eq!(from_ymd(2014, 1, 1) + Duration::zero(),             from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(86399),     from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::seconds(-86399),    from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(1),            from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(-1),           from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(364),          from_ymd(2014, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*4 + 1),    from_ymd(2018, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Duration::days(365*400 + 97), from_ymd(2414, 1, 1));
§

type Output = NaiveDate

The resulting type after applying the + operator.
source§

fn add(self, rhs: OldDuration) -> NaiveDate

Performs the + operation. Read more
source§

impl Add<Months> for NaiveDate

source§

fn add(self, months: Months) -> Self::Output

An addition of months to NaiveDate clamped to valid days in resulting month.

§Panics

Panics if the resulting date would be out of range.

§Example
use chrono::{Duration, NaiveDate, Months};

let from_ymd = NaiveDate::from_ymd;

assert_eq!(from_ymd(2014, 1, 1) + Months::new(1), from_ymd(2014, 2, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(11), from_ymd(2014, 12, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(12), from_ymd(2015, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) + Months::new(13), from_ymd(2015, 2, 1));
assert_eq!(from_ymd(2014, 1, 31) + Months::new(1), from_ymd(2014, 2, 28));
assert_eq!(from_ymd(2020, 1, 31) + Months::new(1), from_ymd(2020, 2, 29));
§

type Output = NaiveDate

The resulting type after applying the + operator.
source§

impl AddAssign<Duration> for NaiveDate

source§

fn add_assign(&mut self, rhs: OldDuration)

Performs the += operation. Read more
source§

impl Clone for NaiveDate

source§

fn clone(&self) -> NaiveDate

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Datelike for NaiveDate

source§

fn year(&self) -> i32

Returns the year number in the calendar date.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().year(), 2015);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().year(), -308); // 309 BCE
source§

fn month(&self) -> u32

Returns the month number starting from 1.

The return value ranges from 1 to 12.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().month(), 9);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().month(), 3);
source§

fn month0(&self) -> u32

Returns the month number starting from 0.

The return value ranges from 0 to 11.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().month0(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().month0(), 2);
source§

fn day(&self) -> u32

Returns the day of month starting from 1.

The return value ranges from 1 to 31. (The last day of month differs by months.)

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day(), 14);

Combined with NaiveDate::pred, one can determine the number of days in a particular month. (Note that this panics when year is out of range.)

use chrono::{NaiveDate, Datelike};

fn ndays_in_month(year: i32, month: u32) -> u32 {
    // the first day of the next month...
    let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) };
    let d = NaiveDate::from_ymd_opt(y, m, 1).unwrap();

    // ...is preceded by the last day of the original month
    d.pred().day()
}

assert_eq!(ndays_in_month(2015, 8), 31);
assert_eq!(ndays_in_month(2015, 9), 30);
assert_eq!(ndays_in_month(2015, 12), 31);
assert_eq!(ndays_in_month(2016, 2), 29);
assert_eq!(ndays_in_month(2017, 2), 28);
source§

fn day0(&self) -> u32

Returns the day of month starting from 0.

The return value ranges from 0 to 30. (The last day of month differs by months.)

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day0(), 7);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day0(), 13);
source§

fn ordinal(&self) -> u32

Returns the day of year starting from 1.

The return value ranges from 1 to 366. (The last day of year differs by years.)

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal(), 251);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal(), 74);

Combined with NaiveDate::pred, one can determine the number of days in a particular year. (Note that this panics when year is out of range.)

use chrono::{NaiveDate, Datelike};

fn ndays_in_year(year: i32) -> u32 {
    // the first day of the next year...
    let d = NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap();

    // ...is preceded by the last day of the original year
    d.pred().ordinal()
}

assert_eq!(ndays_in_year(2015), 365);
assert_eq!(ndays_in_year(2016), 366);
assert_eq!(ndays_in_year(2017), 365);
assert_eq!(ndays_in_year(2000), 366);
assert_eq!(ndays_in_year(2100), 365);
source§

fn ordinal0(&self) -> u32

Returns the day of year starting from 0.

The return value ranges from 0 to 365. (The last day of year differs by years.)

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal0(), 250);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal0(), 73);
source§

fn weekday(&self) -> Weekday

Returns the day of week.

§Example
use chrono::{NaiveDate, Datelike, Weekday};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().weekday(), Weekday::Tue);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().weekday(), Weekday::Fri);
source§

fn with_year(&self, year: i32) -> Option<NaiveDate>

Makes a new NaiveDate with the year number changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_year(2016),
           Some(NaiveDate::from_ymd_opt(2016, 9, 8).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_year(-308),
           Some(NaiveDate::from_ymd_opt(-308, 9, 8).unwrap()));

A leap day (February 29) is a good example that this method can return None.

assert!(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().with_year(2015).is_none());
assert!(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap().with_year(2020).is_some());
source§

fn with_month(&self, month: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the month number (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month(10),
           Some(NaiveDate::from_ymd_opt(2015, 10, 8).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month(13), None); // no month 13
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().with_month(2), None); // no February 30
source§

fn with_month0(&self, month0: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the month number (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month0(9),
           Some(NaiveDate::from_ymd_opt(2015, 10, 8).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_month0(12), None); // no month 13
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap().with_month0(1), None); // no February 30
source§

fn with_day(&self, day: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the day of month (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day(30),
           Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day(31),
           None); // no September 31
source§

fn with_day0(&self, day0: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the day of month (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day0(29),
           Some(NaiveDate::from_ymd_opt(2015, 9, 30).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().with_day0(30),
           None); // no September 31
source§

fn with_ordinal(&self, ordinal: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the day of year (starting from 1) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal(60),
           Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal(366),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal(60),
           Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal(366),
           Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap()));
source§

fn with_ordinal0(&self, ordinal0: u32) -> Option<NaiveDate>

Makes a new NaiveDate with the day of year (starting from 0) changed.

Returns None when the resulting NaiveDate would be invalid.

§Example
use chrono::{NaiveDate, Datelike};

assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal0(59),
           Some(NaiveDate::from_ymd_opt(2015, 3, 1).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2015, 1, 1).unwrap().with_ordinal0(365),
           None); // 2015 had only 365 days

assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal0(59),
           Some(NaiveDate::from_ymd_opt(2016, 2, 29).unwrap()));
assert_eq!(NaiveDate::from_ymd_opt(2016, 1, 1).unwrap().with_ordinal0(365),
           Some(NaiveDate::from_ymd_opt(2016, 12, 31).unwrap()));
source§

fn iso_week(&self) -> IsoWeek

Returns the ISO week.
source§

fn year_ce(&self) -> (bool, u32)

Returns the absolute year number starting from 1 with a boolean flag, which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).
source§

fn num_days_from_ce(&self) -> i32

Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1. Read more
source§

impl Debug for NaiveDate

The Debug output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

§Example

use chrono::NaiveDate;

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(2015,  9,  5).unwrap()), "2015-09-05");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(   0,  1,  1).unwrap()), "0000-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(   -1,  1,  1).unwrap()),  "-0001-01-01");
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");
source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for NaiveDate

The default value for a NaiveDate is 1st of January 1970.

§Example

use chrono::NaiveDate;

let default_date = NaiveDate::default();
assert_eq!(default_date, NaiveDate::from_ymd_opt(1970, 1, 1).unwrap());
source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Display for NaiveDate

The Display output of the naive date d is the same as d.format("%Y-%m-%d").

The string printed can be readily parsed via the parse method on str.

§Example

use chrono::NaiveDate;

assert_eq!(format!("{}", NaiveDate::from_ymd_opt(2015,  9,  5).unwrap()), "2015-09-05");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(   0,  1,  1).unwrap()), "0000-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap()), "9999-12-31");

ISO 8601 requires an explicit sign for years before 1 BCE or after 9999 CE.

assert_eq!(format!("{}", NaiveDate::from_ymd_opt(   -1,  1,  1).unwrap()),  "-0001-01-01");
assert_eq!(format!("{}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap()), "+10000-12-31");
source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl FromStr for NaiveDate

Parsing a str into a NaiveDate uses the same format, %Y-%m-%d, as in Debug and Display.

§Example

use chrono::NaiveDate;

let d = NaiveDate::from_ymd_opt(2015, 9, 18).unwrap();
assert_eq!("2015-09-18".parse::<NaiveDate>(), Ok(d));

let d = NaiveDate::from_ymd_opt(12345, 6, 7).unwrap();
assert_eq!("+12345-6-7".parse::<NaiveDate>(), Ok(d));

assert!("foo".parse::<NaiveDate>().is_err());
§

type Err = ParseError

The associated error which can be returned from parsing.
source§

fn from_str(s: &str) -> ParseResult<NaiveDate>

Parses a string s to return a value of this type. Read more
source§

impl Hash for NaiveDate

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl Ord for NaiveDate

source§

fn cmp(&self, other: &NaiveDate) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for NaiveDate

source§

fn eq(&self, other: &NaiveDate) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for NaiveDate

source§

fn partial_cmp(&self, other: &NaiveDate) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl Sub<Days> for NaiveDate

§

type Output = NaiveDate

The resulting type after applying the - operator.
source§

fn sub(self, days: Days) -> Self::Output

Performs the - operation. Read more
source§

impl Sub<Duration> for NaiveDate

A subtraction of Duration from NaiveDate discards the fractional days, rounding to the closest integral number of days towards Duration::zero(). It is the same as the addition with a negated Duration.

Panics on underflow or overflow. Use NaiveDate::checked_sub_signed to detect that.

§Example

use chrono::{Duration, NaiveDate};

let from_ymd = NaiveDate::from_ymd;

assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(),             from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399),     from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399),    from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1),            from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1),           from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364),          from_ymd(2013, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1),    from_ymd(2010, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
§

type Output = NaiveDate

The resulting type after applying the - operator.
source§

fn sub(self, rhs: OldDuration) -> NaiveDate

Performs the - operation. Read more
source§

impl Sub<Months> for NaiveDate

source§

fn sub(self, months: Months) -> Self::Output

A subtraction of Months from NaiveDate clamped to valid days in resulting month.

§Panics

Panics if the resulting date would be out of range.

§Example
use chrono::{Duration, NaiveDate, Months};

let from_ymd = NaiveDate::from_ymd;

assert_eq!(from_ymd(2014, 1, 1) - Months::new(11), from_ymd(2013, 2, 1));
assert_eq!(from_ymd(2014, 1, 1) - Months::new(12), from_ymd(2013, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Months::new(13), from_ymd(2012, 12, 1));
§

type Output = NaiveDate

The resulting type after applying the - operator.
source§

impl Sub for NaiveDate

Subtracts another NaiveDate from the current date. Returns a Duration of integral numbers.

This does not overflow or underflow at all, as all possible output fits in the range of Duration.

The implementation is a wrapper around NaiveDate::signed_duration_since.

§Example

use chrono::{Duration, NaiveDate};

let from_ymd = NaiveDate::from_ymd;

assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
§

type Output = Duration

The resulting type after applying the - operator.
source§

fn sub(self, rhs: NaiveDate) -> OldDuration

Performs the - operation. Read more
source§

impl SubAssign<Duration> for NaiveDate

source§

fn sub_assign(&mut self, rhs: OldDuration)

Performs the -= operation. Read more
source§

impl Copy for NaiveDate

source§

impl Eq for NaiveDate

source§

impl StructuralPartialEq for NaiveDate

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.