Chrono

https://docs.rs/chrono/latest/chrono
Admin
Chrono is a Rust library that provides comprehensive functionality for handling dates and times in...
Tokens:764,720
Snippets:4,378
Trust Score:9.7
Update:2 days ago
Show doc for...
Tokens:
Raw
### first example

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html

Gets the first day in the collection, starting from Monday. Returns None if the collection is empty. Example shows first on single, ALL, and EMPTY sets.

```rust
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
assert_eq!(WeekdaySet::EMPTY.first(), None);
```

--------------------------------

### NaiveWeek::first_day example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveWeek.html

Shows how to get the first day of a week using NaiveWeek::first_day. Panics if the first day is out of NaiveDate's range.

```rust
use chrono::{NaiveDate, Weekday};

let date = NaiveDate::from_ymd_opt(2022, 4, 18).unwrap();
let week = date.week(Weekday::Mon);
assert!(week.first_day() <= date);
```

--------------------------------

### timestamp() example

Source: https://docs.rs/chrono/latest/chrono/struct.DateTime.html

Shows how to get the Unix timestamp (seconds) from a DateTime<Utc> and verify it with from_timestamp.

```rust
use chrono::{DateTime, TimeZone, Utc};

let dt: DateTime<Utc> = Utc.with_ymd_and_hms(2015, 5, 15, 0, 0, 0).unwrap();
assert_eq!(dt.timestamp(), 1431648000);

assert_eq!(DateTime::from_timestamp(dt.timestamp(), dt.timestamp_subsec_nanos()).unwrap(), dt);
```

--------------------------------

### NaiveDate::to_epoch_days example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

Shows how to use to_epoch_days to get the number of days since the epoch (1970-01-01). The example asserts values for dates before and after the epoch.

```rust
use chrono::NaiveDate;

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

assert_eq!(from_ymd(1, 1, 1).to_epoch_days(), -719162);
assert_eq!(from_ymd(1970, 1, 1).to_epoch_days(), 0);
assert_eq!(from_ymd(2005, 9, 10).to_epoch_days(), 13036);
```

--------------------------------

### ordinal0: Get day of year starting from 0

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

Returns the day of year starting from 0, ranging from 0 to 365. The example shows usage with NaiveDate::from_ymd_opt and asserts the ordinal0 values.

```rust
use chrono::{Datelike, NaiveDate};

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

--------------------------------

### Create NaiveDateTime from NaiveDate and NaiveTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Shows how to create a NaiveDateTime using NaiveDate::from_ymd_opt and and_hms_opt. The example uses unwrap() on the Option results.

```rust
use chrono::{NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2016, 7, 8).unwrap().and_hms_opt(9, 10, 11).unwrap();
```

--------------------------------

### ordinal: Get day of year starting from 1

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

Returns the day of year starting from 1, ranging from 1 to 366. The example shows usage with NaiveDate::from_ymd_opt and asserts the ordinal values.

```rust
use chrono::{Datelike, NaiveDate};

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

--------------------------------

### timestamp_opt example

Source: https://docs.rs/chrono/latest/chrono/offset/trait.TimeZone.html

Creates a DateTime from seconds and nanoseconds, returning MappedLocalTime. The example asserts the resulting string representation.

```rust
use chrono::{TimeZone, Utc};

assert_eq!(Utc.timestamp_opt(1431648000, 0).unwrap().to_string(), "2015-05-15 00:00:00 UTC");
```

--------------------------------

### WeekdaySet::last example

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html

Shows how to get the last day in a WeekdaySet collection, starting from Sunday. Returns None if the collection is empty.

```rust
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
assert_eq!(WeekdaySet::EMPTY.last(), None);
```

--------------------------------

### Example: Using ts_microseconds_option with serde

Source: https://docs.rs/chrono/latest/chrono/naive/serde/ts_microseconds_option/index.html

Shows how to use the ts_microseconds_option module with serde's 'with' attribute on an Option<NaiveDateTime> field. The example includes serialization to JSON and deserialization back, verifying the round-trip.

```rust
use chrono::naive::serde::ts_microseconds_option;
#[derive(Deserialize, Serialize)]
struct S {
    #[serde(with = "ts_microseconds_option")]
    time: Option<NaiveDateTime>,
}

let time = Some(
    NaiveDate::from_ymd_opt(2018, 5, 17)
        .unwrap()
        .and_hms_micro_opt(02, 04, 59, 918355)
        .unwrap(),
);
let my_s = S { time: time.clone() };

let as_string = serde_json::to_string(&my_s)?;
assert_eq!(as_string, r#"{"time":1526522699918355}"#);
let my_s: S = serde_json::from_str(&as_string)?;
assert_eq!(my_s.time, time);
```

--------------------------------

### Get day of month from NaiveDateTime using Datelike::day

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the day of month starting from 1, ranging from 1 to 31. The example asserts the day is 25.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day(), 25);
```

--------------------------------

### Example: Serialize NaiveDateTime to nanoseconds

Source: https://docs.rs/chrono/latest/chrono/naive/serde/ts_nanoseconds/fn.serialize.html

Example showing how to use `serialize` with serde's `serialize_with` attribute. It defines a struct with a `NaiveDateTime` field and serializes it to JSON, producing a string with the timestamp in nanoseconds.

```rust
use chrono::naive::serde::ts_nanoseconds::serialize as to_nano_ts;
#[derive(Serialize)]
struct S {
    #[serde(serialize_with = "to_nano_ts")]
    time: NaiveDateTime,
}

let my_s = S {
    time: NaiveDate::from_ymd_opt(2018, 5, 17)
        .unwrap()
        .and_hms_nano_opt(02, 04, 59, 918355733)
        .unwrap(),
};
let as_string = serde_json::to_string(&my_s)?;
assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
```

--------------------------------

### Get day of year (0-based) with NaiveDateTime::ordinal0

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the day of year starting from 0, ranging from 0 to 365. The example uses the same date and asserts the ordinal0 is 267.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
```

--------------------------------

### Add TimeDelta to NaiveTime (basic example)

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Shows basic addition of TimeDelta to NaiveTime using from_hms_milli_opt and TimeDelta methods. The addition wraps around and ignores integral days.

```rust
use chrono::{NaiveTime, TimeDelta};

let from_hmsm = |h, m, s, milli| NaiveTime::from_hms_milli_opt(h, m, s, milli).unwrap();

assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::zero(), from_hmsm(3, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::try_seconds(1).unwrap(), from_hmsm(3, 5, 8, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::try_seconds(-1).unwrap(), from_hmsm(3, 5, 6, 0));
assert_eq!(
    from_hmsm(3, 5, 7, 0) + TimeDelta::try_seconds(60 + 4).unwrap(),
    from_hmsm(3, 6, 11, 0)
);
assert_eq!(
    from_hmsm(3, 5, 7, 0) + TimeDelta::try_seconds(7 * 60 * 60 - 6 * 60).unwrap(),
    from_hmsm(9, 59, 7, 0)
);
assert_eq!(
    from_hmsm(3, 5, 7, 0) + TimeDelta::try_milliseconds(80).unwrap(),
    from_hmsm(3, 5, 7, 80)
);
assert_eq!(
    from_hmsm(3, 5, 7, 950) + TimeDelta::try_milliseconds(280).unwrap(),
    from_hmsm(3, 5, 8, 230)
);
assert_eq!(
    from_hmsm(3, 5, 7, 950) + TimeDelta::try_milliseconds(-980).unwrap(),
    from_hmsm(3, 5, 6, 970)
);
```

--------------------------------

### Get zero-based month from NaiveDateTime using Datelike::month0

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the month number starting from 0, ranging from 0 to 11. The example asserts the month0 is 8 for September.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month0(), 8);
```

--------------------------------

### Local::now() usage examples

Source: https://docs.rs/chrono/latest/chrono/offset/struct.Local.html

Demonstrates various ways to obtain the current local time and date, convert to FixedOffset, and convert to another timezone. Includes a note that using Utc::now is more efficient for timezone conversion.

```rust
// Current local time
let now = Local::now();

// Current local date
let today = now.date_naive();

// Current local time, converted to `DateTime<FixedOffset>`
let now_fixed_offset = Local::now().fixed_offset();
// or
let now_fixed_offset: DateTime<FixedOffset> = Local::now().into();

// Current time in some timezone (let's use +05:00)
// Note that it is usually more efficient to use `Utc::now` for this use case.
let offset = FixedOffset::east_opt(5 * 60 * 60).unwrap();
let now_with_offset = Local::now().with_timezone(&offset);
```

--------------------------------

### Get month from NaiveDateTime using Datelike::month

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the month number starting from 1, ranging from 1 to 12. The example asserts the month is 9 for the date 2015-09-25.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month(), 9);
```

--------------------------------

### Get zero-based day of month from NaiveDateTime using Datelike::day0

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the day of month starting from 0, ranging from 0 to 30. The example asserts the day0 is 24 for the 25th.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
```

--------------------------------

### Construct custom date and time with Chrono

Source: https://docs.rs/chrono/latest/chrono/

Shows various ways to construct a DateTime<Utc> using with_ymd_and_hms, NaiveDate methods, and dynamic verification with MappedLocalTime. Also demonstrates constructing local and fixed-offset datetimes from local datetime components.

```rust
use chrono::offset::MappedLocalTime;
use chrono::prelude::*;


let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap(); // `2014-07-08T09:10:11Z`
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_opt(9, 10, 11)?
        .and_utc()
);

// July 8 is 188th day of the year 2014 (`o` for "ordinal")
assert_eq!(dt, NaiveDate::from_yo_opt(2014, 189)?.and_hms_opt(9, 10, 11)?.and_utc());
// July 8 is Tuesday in ISO week 28 of the year 2014.
assert_eq!(
    dt,
    NaiveDate::from_isoywd_opt(2014, 28, Weekday::Tue)?.and_hms_opt(9, 10, 11)?.and_utc()
);

let dt = NaiveDate::from_ymd_opt(2014, 7, 8)?
    .and_hms_milli_opt(9, 10, 11, 12)?
    .and_utc(); // `2014-07-08T09:10:11.012Z`
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_micro_opt(9, 10, 11, 12_000)?
        .and_utc()
);
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_nano_opt(9, 10, 11, 12_000_000)?
        .and_utc()
);

// dynamic verification
assert_eq!(
    Utc.with_ymd_and_hms(2014, 7, 8, 21, 15, 33),
    MappedLocalTime::Single(
        NaiveDate::from_ymd_opt(2014, 7, 8)?.and_hms_opt(21, 15, 33)?.and_utc()
    )
);
assert_eq!(Utc.with_ymd_and_hms(2014, 7, 8, 80, 15, 33), MappedLocalTime::None);
assert_eq!(Utc.with_ymd_and_hms(2014, 7, 38, 21, 15, 33), MappedLocalTime::None);

// other time zone objects can be used to construct a local datetime.
// obviously, `local_dt` is normally different from `dt`, but `fixed_dt` should be identical.
let local_dt = Local
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2014, 7, 8).unwrap().and_hms_milli_opt(9, 10, 11, 12).unwrap(),
    )
    .unwrap();
let fixed_dt = FixedOffset::east_opt(9 * 3600)
    .unwrap()
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2014, 7, 8)
            .unwrap()
            .and_hms_milli_opt(18, 10, 11, 12)
            .unwrap(),
    )
    .unwrap();
assert_eq!(dt, fixed_dt);
```

--------------------------------

### Example: Using ts_milliseconds_option::serialize with serde

Source: https://docs.rs/chrono/latest/chrono/naive/serde/ts_milliseconds_option/fn.serialize.html

Example showing how to use the serialize function with the serialize_with attribute. It serializes an Option<NaiveDateTime> to a JSON string with milliseconds since epoch.

```rust
use chrono::naive::serde::ts_milliseconds_option::serialize as to_milli_tsopt;
#[derive(Serialize)]
struct S {
    #[serde(serialize_with = "to_milli_tsopt")]
    time: Option<NaiveDateTime>,
}

let my_s = S {
    time: Some(
        NaiveDate::from_ymd_opt(2018, 5, 17)
            .unwrap()
            .and_hms_milli_opt(02, 04, 59, 918)
            .unwrap(),
    ),
};
let as_string = serde_json::to_string(&my_s)?;
assert_eq!(as_string, r#"{"time":1526522699918}"#);
```

--------------------------------

### Get day of year (1-based) with NaiveDateTime::ordinal

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Returns the day of year starting from 1, ranging from 1 to 366. The example creates a NaiveDateTime for 2015-09-25 12:34:56 and asserts the ordinal is 268.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

--------------------------------

### date_naive example

Source: https://docs.rs/chrono/latest/chrono/struct.DateTime.html

Shows how to use DateTime::date_naive() to retrieve the date component. The example creates two DateTime instances with different timezones (Utc and FixedOffset) and asserts that their date_naive() values are equal.

```rust
use chrono::prelude::*;

let date: DateTime<Utc> = Utc.with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
let other: DateTime<FixedOffset> =
    FixedOffset::east_opt(23).unwrap().with_ymd_and_hms(2020, 1, 1, 0, 0, 0).unwrap();
assert_eq!(date.date_naive(), other.date_naive());
```

--------------------------------

### Weekday usage example

Source: https://docs.rs/chrono/latest/chrono/enum.Weekday.html

Example showing how to parse a Weekday from a string, convert from an integer, and use methods like num_days_from_monday, succ, and pred.

```rust
use chrono::Weekday;

let monday = "Monday".parse::<Weekday>().unwrap();
assert_eq!(monday, Weekday::Mon);

let sunday = Weekday::try_from(6).unwrap();
assert_eq!(sunday, Weekday::Sun);

assert_eq!(sunday.num_days_from_monday(), 6); // starts counting with Monday = 0
assert_eq!(sunday.number_from_monday(), 7); // starts counting with Monday = 1
assert_eq!(sunday.num_days_from_sunday(), 0); // starts counting with Sunday = 0
assert_eq!(sunday.number_from_sunday(), 1); // starts counting with Sunday = 1

assert_eq!(sunday.succ(), monday);
assert_eq!(sunday.pred(), Weekday::Sat);
```

--------------------------------

### num_seconds_from_midnight example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Shows how to use NaiveTime::num_seconds_from_midnight to get the number of non-leap seconds since the last midnight. Includes examples with different time values.

```rust
use chrono::{NaiveTime, Timelike};

assert_eq!(NaiveTime::from_hms_opt(1, 2, 3).unwrap().num_seconds_from_midnight(), 3723);
assert_eq!(
    NaiveTime::from_hms_nano_opt(23, 56, 4, 12_345_678).unwrap().num_seconds_from_midnight(),
    86164
);
assert_eq!(
    NaiveTime::from_hms_milli_opt(23, 59, 59, 1_000).unwrap().num_seconds_from_midnight(),
    86399
);
```

--------------------------------

### Get month name with Month::name

Source: https://docs.rs/chrono/latest/chrono/enum.Month.html

Shows how to use Month::name() to get the name of a month. The example asserts that Month::January.name() returns "January".

```rust
use chrono::Month;

assert_eq!(Month::January.name(), "January")
```

--------------------------------

### Timelike::minute example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Shows how to use the minute() method on NaiveTime. It asserts that the minute is 0 for midnight and 56 for a time with nanoseconds.

```rust
use chrono::{NaiveTime, Timelike};

assert_eq!(NaiveTime::from_hms_opt(0, 0, 0).unwrap().minute(), 0);
assert_eq!(NaiveTime::from_hms_nano_opt(23, 56, 4, 12_345_678).unwrap().minute(), 56);
```

--------------------------------

### timestamp_micros() example

Source: https://docs.rs/chrono/latest/chrono/struct.DateTime.html

Shows how to get the Unix timestamp in microseconds from DateTime<Utc> values.

```rust
use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_micro_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_micro_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_micros(), 1_000_000_000_000_555);
```

--------------------------------

### Construct NaiveDateTime with NaiveDateTime::new

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Shows how to use the NaiveDateTime::new constructor with a NaiveDate and NaiveTime, and verifies the date and time components.

```rust
use chrono::{NaiveDate, NaiveDateTime, NaiveTime};

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::new(d, t);
assert_eq!(dt.date(), d);
assert_eq!(dt.time(), t);
```

--------------------------------

### timestamp_millis() example

Source: https://docs.rs/chrono/latest/chrono/struct.DateTime.html

Shows how to get the Unix timestamp in milliseconds from DateTime<Utc> values.

```rust
use chrono::{NaiveDate, Utc};

let dt = NaiveDate::from_ymd_opt(1970, 1, 1)
    .unwrap()
    .and_hms_milli_opt(0, 0, 1, 444)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_444);

let dt = NaiveDate::from_ymd_opt(2001, 9, 9)
    .unwrap()
    .and_hms_milli_opt(1, 46, 40, 555)
    .unwrap()
    .and_local_timezone(Utc)
    .unwrap();
assert_eq!(dt.timestamp_millis(), 1_000_000_000_555);
```

--------------------------------

### Display formatting examples for NaiveTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Shows how to format NaiveTime values using the Display trait. The output is the same as t.format("%H:%M:%S%.f"). The first block demonstrates formatting with various precision (seconds, milliseconds, microseconds, nanoseconds). The second block shows formatting a leap second, which may print a representation not distinguishable from non-leap seconds.

```rust
use chrono::NaiveTime;

assert_eq!(format!("{}", NaiveTime::from_hms_opt(23, 56, 4).unwrap()), "23:56:04");
assert_eq!(
    format!("{}", NaiveTime::from_hms_milli_opt(23, 56, 4, 12).unwrap()),
    "23:56:04.012"
);
assert_eq!(
    format!("{}", NaiveTime::from_hms_micro_opt(23, 56, 4, 1234).unwrap()),
    "23:56:04.001234"
);
assert_eq!(
    format!("{}", NaiveTime::from_hms_nano_opt(23, 56, 4, 123456).unwrap()),
    "23:56:04.000123456"
);
```

```rust
assert_eq!(
    format!("{}", NaiveTime::from_hms_milli_opt(6, 59, 59, 1_500).unwrap()),
    "06:59:60.500"
);
```

--------------------------------

### format_with_items example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Shows how to format a NaiveTime using custom formatting items with format_with_items. The iterator of items must be Cloneable because the resulting DelayedFormat may be formatted multiple times.

```rust
use chrono::format::strftime::StrftimeItems;
use chrono::NaiveTime;

let fmt = StrftimeItems::new("%H:%M:%S");
let t = NaiveTime::from_hms_opt(23, 56, 4).unwrap();
assert_eq!(t.format_with_items(fmt.clone()).to_string(), "23:56:04");
assert_eq!(t.format("%H:%M:%S").to_string(), "23:56:04");
```

--------------------------------

### IsoWeek::week example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.IsoWeek.html

Shows how to get the ISO week number (1-53) from an IsoWeek.

```rust
use chrono::{Datelike, NaiveDate, Weekday};

let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week(), 15);
```

--------------------------------

### NaiveTime::from_hms_opt example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveTime.html

Example showing how to use NaiveTime::from_hms_opt to create a NaiveTime from hour, minute, and second. It returns Some for valid times and None for invalid ones, such as hour 24, minute 60, or second 60.

```rust
use chrono::NaiveTime;

let from_hms_opt = NaiveTime::from_hms_opt;

assert!(from_hms_opt(0, 0, 0).is_some());
assert!(from_hms_opt(23, 59, 59).is_some());
assert!(from_hms_opt(24, 0, 0).is_none());
assert!(from_hms_opt(23, 60, 0).is_none());
assert!(from_hms_opt(23, 59, 60).is_none());
```

--------------------------------

### Example: Using ts_nanoseconds with serde

Source: https://docs.rs/chrono/latest/chrono/serde/ts_nanoseconds/index.html

Shows how to use `ts_nanoseconds` with `#[serde(with = "ts_nanoseconds")]` to serialize a `DateTime<Utc>` to a nanosecond timestamp and deserialize it back. The example includes a round-trip test with `serde_json`.

```rust
use chrono::serde::ts_nanoseconds;
#[derive(Deserialize, Serialize)]
struct S {
    #[serde(with = "ts_nanoseconds")]
    time: DateTime<Utc>,
}

let time = NaiveDate::from_ymd_opt(2018, 5, 17)
    .unwrap()
    .and_hms_nano_opt(02, 04, 59, 918355733)
    .unwrap()
    .and_utc();
let my_s = S { time: time.clone() };

let as_string = serde_json::to_string(&my_s)?;
assert_eq!(as_string, r#"{"time":1526522699918355733}"#);
let my_s: S = serde_json::from_str(&as_string)?;
assert_eq!(my_s.time, time);
```

--------------------------------

### IsoWeek::week0 example

Source: https://docs.rs/chrono/latest/chrono/naive/struct.IsoWeek.html

Shows how to get the zero-based ISO week number (0-52) from an IsoWeek.

```rust
use chrono::{Datelike, NaiveDate, Weekday};

let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week0(), 14);
```

--------------------------------

### first

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html

Get the first day in the collection, starting from Monday. Returns `None` if the collection is empty.

```APIDOC
## first

### Description
Get the first day in the collection, starting from Monday. Returns `None` if the collection is empty.

### Method
`pub const fn first(self) -> Option<Weekday>`

### Parameters
- `self` (WeekdaySet) - The set to query.

### Returns
- `Option<Weekday>` - The first weekday in the set, or `None` if empty.

### Example
```rust
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
assert_eq!(WeekdaySet::EMPTY.first(), None);
```
```

--------------------------------

### timestamp_millis_opt example

Source: https://docs.rs/chrono/latest/chrono/offset/trait.TimeZone.html

Creates a DateTime from milliseconds, returning MappedLocalTime. The example matches on the result and asserts the timestamp.

```rust
use chrono::{MappedLocalTime, TimeZone, Utc};
match Utc.timestamp_millis_opt(1431648000) {
    MappedLocalTime::Single(dt) => assert_eq!(dt.timestamp(), 1431648),
    _ => panic!("Incorrect timestamp_millis"),
};
```
Tokens:
Raw