[time] - C++20 → C++23

Files changed (1) hide show

tmp/tmppkl0c77_/{from.md → to.md} +262 -156

tmp/tmppkl0c77_/{from.md → to.md} RENAMED Viewed

@@ -30,38 +30,39 @@ and `L"..."` if `charT` is `wchar_t`.
 ## Header `<chrono>` synopsis <a id="time.syn">[[time.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
-namespace std {
-  namespace chrono {
   // [time.duration], class template duration
   template<class Rep, class Period = ratio<1>> class duration;
   // [time.point], class template time_point
   template<class Clock, class Duration = typename Clock::duration> class time_point;
 }
   // [time.traits.specializations], common_type specializations
   template<class Rep1, class Period1, class Rep2, class Period2>
     struct common_type<chrono::duration<Rep1, Period1>,
                        chrono::duration<Rep2, Period2>>;
   template<class Clock, class Duration1, class Duration2>
     struct common_type<chrono::time_point<Clock, Duration1>,
                        chrono::time_point<Clock, Duration2>>;
- namespace chrono {
   // [time.traits], customization traits
   template<class Rep> struct treat_as_floating_point;
   template<class Rep>
-      inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;
   template<class Rep> struct duration_values;
   template<class T> struct is_clock;
- template<class T> inline constexpr bool is_clock_v = is_clock<T>::value;
   // [time.duration.nonmember], duration arithmetic
   template<class Rep1, class Period1, class Rep2, class Period2>
     constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
       operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
@@ -561,11 +562,11 @@ namespace std {
   constexpr year_month_weekday
     operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
- operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwdi);
   // [time.cal.ymwdlast], class year_month_weekday_last
   class year_month_weekday_last;
   constexpr bool operator==(const year_month_weekday_last& x,
@@ -737,31 +738,31 @@ namespace std {
                  const zoned_time<Duration, TimeZonePtr>& t);
   // [time.zone.leap], leap second support
   class leap_second;
- bool operator==(const leap_second& x, const leap_second& y);
- strong_ordering operator<=>(const leap_second& x, const leap_second& y);
   template<class Duration>
- bool operator==(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
- bool operator< (const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
- bool operator< (const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
- bool operator> (const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
- bool operator> (const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
- bool operator<=(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
- bool operator<=(const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
- bool operator>=(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
- bool operator>=(const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
     requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
     constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
   // [time.zone.link], class time_zone_link
@@ -776,10 +777,11 @@ namespace std {
     local-time-format-t<Duration>
       local_time_format(local_time<Duration> time, const string* abbrev = nullptr,
                         const seconds* offset_sec = nullptr);
 }
   template<class Rep, class Period, class charT>
     struct formatter<chrono::duration<Rep, Period>, charT>;
   template<class Duration, class charT>
     struct formatter<chrono::sys_time<Duration>, charT>;
   template<class Duration, class charT>
@@ -813,30 +815,45 @@ namespace std {
     struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;
   template<class charT> struct formatter<chrono::sys_info, charT>;
   template<class charT> struct formatter<chrono::local_info, charT>;
   template<class Duration, class TimeZonePtr, class charT>
     struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
- namespace chrono {
   // [time.parse], parsing
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
- parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
- parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
             basic_string<charT, traits, Alloc>& abbrev);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
- parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
             minutes& offset);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
- parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
             basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
   // calendrical constants
   inline constexpr last_spec last{};
@@ -860,12 +877,11 @@ namespace std {
   inline constexpr month October{10};
   inline constexpr month November{11};
   inline constexpr month December{12};
 }
-  inline namespace literals {
-  inline namespace chrono_literals {
   // [time.duration.literals], suffixes for duration literals
   constexpr chrono::hours                                 operator""h(unsigned long long);
   constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double);
   constexpr chrono::minutes                             operator""min(unsigned long long);
@@ -887,16 +903,14 @@ namespace std {
   constexpr chrono::day  operator""d(unsigned long long d) noexcept;
   // [time.cal.year.nonmembers], non-member functions
   constexpr chrono::year operator""y(unsigned long long y) noexcept;
 }
-  }
- namespace chrono {
   using namespace literals::chrono_literals;
 }
-}
 ```
 ## *Cpp17Clock* requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
@@ -916,19 +930,18 @@ calls occur before `C1::time_point::max()`.
 by a given clock and the SI definition is a measure of the quality of
 implementation. — *end note*]
 A type `TC` meets the *Cpp17TrivialClock* requirements if:
-- `TC` meets the *Cpp17Clock* requirements [[time.clock.req]],
 - the types `TC::rep`, `TC::duration`, and `TC::time_point` meet the
   *Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) and
-  *Cpp17LessThanComparable* ([[cpp17.lessthancomparable]]) requirements
- and the requirements of numeric types [[numeric.requirements]].
   \[*Note 3*: This means, in particular, that operations on these types
   will not throw exceptions. — *end note*]
-- lvalues of the types `TC::rep`, `TC::duration`, and `TC::time_point`
-  are swappable [[swappable.requirements]],
 - the function `TC::now()` does not throw exceptions, and
 - the type `TC::time_point::clock` meets the *Cpp17TrivialClock*
   requirements, recursively.
 ## Time-related traits <a id="time.traits">[[time.traits]]</a>
@@ -965,22 +978,22 @@ template<class Rep>
   };
 ```
 The `duration` template uses the `duration_values` trait to construct
 special values of the duration’s representation (`Rep`). This is done
-because the representation might be a class type with behavior which
 requires some other implementation to return these special values. In
 that case, the author of that class type should specialize
 `duration_values` to return the indicated values.
 ``` cpp
 static constexpr Rep zero() noexcept;
 ```
 *Returns:* `Rep(0)`.
-[*Note 1*: `Rep(0)` is specified instead of `Rep()` because `Rep()` may
 have some other meaning, such as an uninitialized value. — *end note*]
 *Remarks:* The value returned shall be the additive identity.
 ``` cpp
@@ -1019,11 +1032,11 @@ multiple of `Period1::den` and `Period2::den`. — *end note*]
 [*Note 2*: The `typedef` name `type` is a synonym for the `duration`
 with the largest tick `period` possible where both `duration` arguments
 will convert to it without requiring a division operation. The
 representation of this type is intended to be able to hold any value
 resulting from this conversion with no truncation error, although
-floating-point durations may have round-off errors. — *end note*]
 ``` cpp
 template<class Clock, class Duration1, class Duration2>
   struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
     using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
@@ -1049,19 +1062,21 @@ unspecified, except that as a minimum a type `T` shall not qualify as a
 *Cpp17Clock* unless it meets all of the following conditions:
 - the *qualified-id*s `T::rep`, `T::period`, `T::duration`, and
   `T::time_point` are valid and each denotes a type [[temp.deduct]],
 - the expression `T::is_steady` is well-formed when treated as an
-  unevaluated operand,
 - the expression `T::now()` is well-formed when treated as an
   unevaluated operand.
 The behavior of a program that adds specializations for `is_clock` is
 undefined.
 ## Class template `duration` <a id="time.duration">[[time.duration]]</a>
 A `duration` type measures time between two points in time
 (`time_point`s). A `duration` has a representation which holds a count
 of ticks and a tick period. The tick period is the amount of time which
 occurs from one tick to the next, in units of seconds. It is expressed
 as a rational constant using the template `ratio`.
@@ -1125,12 +1140,11 @@ ill-formed. If `Period::num` is not positive, the program is ill-formed.
 Members of `duration` do not throw exceptions other than those thrown by
 the indicated operations on their representations.
 The defaulted copy constructor of duration shall be a constexpr function
 if and only if the required initialization of the member `rep_` for copy
-and move, respectively, would satisfy the requirements for a constexpr
-function.
 [*Example 1*:
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
@@ -1160,11 +1174,11 @@ duration<int, milli> d(3);          // OK
 duration<int, milli> d(3.5);        // error
 ```
 — *end example*]
-*Ensures:* `count() == static_cast<rep>(r)`.
 ``` cpp
 template<class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
@@ -1657,11 +1671,11 @@ where *`units-suffix`* depends on the type `Period::type` as follows:
   `"d"`.
 - Otherwise, if `Period::type::den == 1`, *`units-suffix`* is
   `"[`*`num`*`]s"`.
 - Otherwise, *`units-suffix`* is `"[`*`num`*`/`*`den`*`]s"`.
-In the list above, the use of *`num`* and *`den`* refer to the static
 data members of `Period::type`, which are converted to arrays of `charT`
 using a decimal conversion with no leading zeroes.
 *Returns:* `os`.
@@ -1674,22 +1688,23 @@ template<class charT, class traits, class Rep, class Period, class Alloc = alloc
                 minutes* offset = nullptr);
 ```
 *Effects:* Attempts to parse the input stream `is` into the duration `d`
 using the format flags given in the NTCTS `fmt` as specified in
-[[time.parse]]. If the parse parses everything specified by the parsing
-format flags without error, and yet none of the flags impacts a
-duration, `d` will be assigned a zero value. If `%Z` is used and
-successfully parsed, that value will be assigned to `*abbrev` if
-`abbrev` is non-null. If `%z` (or a modified variant) is used and
-successfully parsed, that value will be assigned to `*offset` if
-`offset` is non-null.
 *Returns:* `is`.
 ## Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 namespace std::chrono {
   template<class Clock, class Duration = typename Clock::duration>
   class time_point {
   public:
@@ -1724,14 +1739,11 @@ namespace std::chrono {
     static constexpr time_point max() noexcept;
   };
 }
 ```
-`Clock` shall either meet the *Cpp17Clock* requirements
-[[time.clock.req]] or be the type `local_t`.
-If `Duration` is not an instance of `duration`, the program is
 ill-formed.
 ### Constructors <a id="time.point.cons">[[time.point.cons]]</a>
 ``` cpp
@@ -1958,11 +1970,13 @@ template<class ToDuration, class Clock, class Duration>
 *Returns:*
 `time_point<Clock, ToDuration>(round<ToDuration>(tp.time_since_epoch()))`.
 ## Clocks <a id="time.clock">[[time.clock]]</a>
-The types defined in this subclause meet the *Cpp17TrivialClock*
 requirements [[time.clock.req]] unless otherwise specified.
 ### Class `system_clock` <a id="time.clock.system">[[time.clock.system]]</a>
 #### Overview <a id="time.clock.system.overview">[[time.clock.system.overview]]</a>
@@ -2040,13 +2054,11 @@ template<class charT, class traits, class Duration>
 `false`, and `Duration{1} < days{1}` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
-auto const dp = floor<days>(tp);
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{} {}"),
-                    year_month_day{dp}, hh_mm_ss{tp-dp});
 ```
 [*Example 1*:
 ``` cpp
@@ -2125,11 +2137,12 @@ measure time since this epoch instead, one can add/subtract the constant
 [*Example 1*:
 `clock_cast<utc_clock>(sys_seconds{sys_days{1970y/January/1}}).time_since_epoch()`
 is `0s`.
 `clock_cast<utc_clock>(sys_seconds{sys_days{2000y/January/1}}).time_since_epoch()`
-is `946'684'822s`, which is `10'957 * 86'400s + 22s`.
  — *end example*]
 `utc_clock` is not a *Cpp17TrivialClock* unless the implementation can
 guarantee that `utc_clock::now()` does not propagate an exception.
@@ -2197,11 +2210,11 @@ template<class charT, class traits, class Duration>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
@@ -2368,11 +2381,11 @@ template<class charT, class traits, class Duration>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
@@ -2466,11 +2479,11 @@ template<class Duration>
 ```
 *Returns:*
 ``` cpp
-gps_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 315964809s
 ```
 [*Note 1*:
 ``` cpp
@@ -2508,11 +2521,11 @@ template<class charT, class traits, class Duration>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
@@ -2564,11 +2577,11 @@ namespace std::chrono {
 requirements [[time.clock.req]], and using a signed arithmetic type for
 `file_clock::rep`. `file_clock` is used to create the `time_point`
 system used for `file_time_type` [[filesystems]]. Its epoch is
 unspecified, and `noexcept(file_clock::now())` is `true`.
-[*Note 1*: The type that `file_clock` denotes may be in a different
 namespace than `std::chrono`, such as `std::filesystem`. — *end note*]
 #### Member functions <a id="time.clock.file.members">[[time.clock.file.members]]</a>
 The type denoted by `file_clock` provides precisely one of the following
@@ -2608,11 +2621,11 @@ template<class charT, class traits, class Duration>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
 ```
 ``` cpp
 template<class charT, class traits, class Duration, class Alloc = allocator<charT>>
   basic_istream<charT, traits>&
@@ -2856,12 +2869,12 @@ template<class Duration>
     -> decltype(SourceClock::to_sys(t));
 ```
 *Constraints:* `SourceClock::to_sys(t)` is well-formed.
-*Mandates:* `SourceClock::to_sys(t)` returns a `sys_time<Duration>`,
-where `Duration` is a valid `chrono::duration` specialization.
 *Returns:* `SourceClock::to_sys(t)`.
 ``` cpp
 template<class DestClock>
@@ -2879,12 +2892,12 @@ template<class Duration>
 ```
 *Constraints:* `DestClock::from_sys(t)` is well-formed.
 *Mandates:* `DestClock::from_sys(t)` returns a
-`time_point<DestClock, Duration>`, where `Duration` is a valid
-`chrono::duration` specialization.
 *Returns:* `DestClock::from_sys(t)`.
 #### Conversions between `utc_clock` and other clocks <a id="time.clock.cast.utc">[[time.clock.cast.utc]]</a>
@@ -2903,12 +2916,12 @@ template<class Duration>
     -> decltype(SourceClock::to_utc(t));
 ```
 *Constraints:* `SourceClock::to_utc(t)` is well-formed.
-*Mandates:* `SourceClock::to_utc(t)` returns a `utc_time<Duration>`,
-where `Duration` is a valid `chrono::duration` specialization.
 *Returns:* `SourceClock::to_utc(t)`.
 ``` cpp
 template<class DestClock>
@@ -2926,12 +2939,12 @@ template<class Duration>
 ```
 *Constraints:* `DestClock::from_utc(t)` is well-formed.
 *Mandates:* `DestClock::from_utc(t)` returns a
-`time_point<DestClock, Duration>`, where `Duration` is a valid
-`chrono::duration` specialization.
 *Returns:* `DestClock::from_utc(t)`.
 #### Function template `clock_cast` <a id="time.clock.cast.fn">[[time.clock.cast.fn]]</a>
@@ -3359,11 +3372,11 @@ template<class charT, class traits>
 *Effects:* Equivalent to:
 ``` cpp
 return os << (m.ok() ?
-  format(os.getloc(), STATICALLY-WIDEN<charT>("{:%b}"), m) :
   format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid month"),
          static_cast<unsigned>(m)));
 ```
 ``` cpp
@@ -3494,11 +3507,11 @@ constexpr year operator+() const noexcept;
 ```
 *Returns:* `*this`.
 ``` cpp
-constexpr year year::operator-() const noexcept;
 ```
 *Returns:* `year{-y_}`.
 ``` cpp
@@ -3547,11 +3560,11 @@ constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
 ``` cpp
 constexpr year operator+(const year& x, const years& y) noexcept;
 ```
-*Returns:* `year{int{x} + y.count()}`.
 ``` cpp
 constexpr year operator+(const years& x, const year& y) noexcept;
 ```
@@ -3823,11 +3836,11 @@ template<class charT, class traits>
 *Effects:* Equivalent to:
 ``` cpp
 return os << (wd.ok() ?
-  format(os.getloc(), STATICALLY-WIDEN<charT>("{:%a}"), wd) :
   format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid weekday"),
          static_cast<unsigned>(wd.wd_)));
 ```
 ``` cpp
@@ -3935,12 +3948,12 @@ template<class charT, class traits>
 *Effects:* Equivalent to:
 ``` cpp
 auto i = wdi.index();
 return os << (i >= 1 && i <= 5 ?
-  format(os.getloc(), STATICALLY-WIDEN<charT>("{}[{}]"), wdi.weekday(), i) :
-  format(os.getloc(), STATICALLY-WIDEN<charT>("{}[{} is not a valid index]"),
          wdi.weekday(), i));
 ```
 ### Class `weekday_last` <a id="time.cal.wdlast">[[time.cal.wdlast]]</a>
@@ -4011,11 +4024,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}[last]"), wdl.weekday());
 ```
 ### Class `month_day` <a id="time.cal.md">[[time.cal.md]]</a>
 #### Overview <a id="time.cal.md.overview">[[time.cal.md.overview]]</a>
@@ -4099,11 +4112,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"),
                     md.month(), md.day());
 ```
 ``` cpp
 template<class charT, class traits, class Alloc = allocator<charT>>
@@ -4194,11 +4207,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/last"), mdl.month());
 ```
 ### Class `month_weekday` <a id="time.cal.mwd">[[time.cal.mwd]]</a>
 #### Overview <a id="time.cal.mwd.overview">[[time.cal.mwd.overview]]</a>
@@ -4277,11 +4290,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"),
                     mwd.month(), mwd.weekday_indexed());
 ```
 ### Class `month_weekday_last` <a id="time.cal.mwdlast">[[time.cal.mwdlast]]</a>
@@ -4364,11 +4377,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"),
                     mwdl.month(), mwdl.weekday_last());
 ```
 ### Class `year_month` <a id="time.cal.ym">[[time.cal.ym]]</a>
@@ -4564,11 +4577,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"),
                     ym.year(), ym.month());
 ```
 ``` cpp
 template<class charT, class traits, class Alloc = allocator<charT>>
@@ -4654,11 +4667,11 @@ constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
 *Effects:* Initializes `y_` with `ymdl.year()`, `m_` with
 `ymdl.month()`, and `d_` with `ymdl.day()`.
 [*Note 1*: This conversion from `year_month_day_last` to
-`year_month_day` may be more efficient than converting a
 `year_month_day_last` to a `sys_days`, and then converting that
 `sys_days` to a `year_month_day`. — *end note*]
 ``` cpp
 constexpr year_month_day(const sys_days& dp) noexcept;
@@ -4838,11 +4851,11 @@ constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) n
 ```
 *Returns:* `(ymd.year() + dy) / ymd.month() / ymd.day()`.
 [*Note 2*: If `ymd.month()` is February and `ymd.day()` is not in the
-range \[`1d`, `28d`\], `ok()` may return `false` for the resultant
 `year_month_day`. — *end note*]
 ``` cpp
 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
 ```
@@ -5011,11 +5024,11 @@ constexpr chrono::day day() const noexcept;
 *Returns:* If `ok()` is `true`, returns a `day` representing the last
 day of the (`year`, `month`) pair represented by `*this`. Otherwise, the
 returned value is unspecified.
-[*Note 1*: This value may be computed on demand. — *end note*]
 ``` cpp
 constexpr operator sys_days() const noexcept;
 ```
@@ -5118,11 +5131,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}"),
                     ymdl.year(), ymdl.month_day_last());
 ```
 ### Class `year_month_weekday` <a id="time.cal.ymwd">[[time.cal.ymwd]]</a>
@@ -5190,12 +5203,12 @@ constexpr year_month_weekday(const sys_days& dp) noexcept;
 ```
 *Effects:* Constructs an object of type `year_month_weekday` which
 corresponds to the date represented by `dp`.
-*Remarks:* For any value `ymdl` of type `year_month_weekday` for which
-`ymdl.ok()` is `true`, `ymdl == year_month_weekday{sys_days{ymdl}}` is
 `true`.
 ``` cpp
 constexpr explicit year_month_weekday(const local_days& dp) noexcept;
 ```
@@ -5369,11 +5382,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}/{}"),
                     ymwd.year(), ymwd.month(), ymwd.weekday_indexed());
 ```
 ### Class `year_month_weekday_last` <a id="time.cal.ymwdlast">[[time.cal.ymwdlast]]</a>
@@ -5596,11 +5609,11 @@ template<class charT, class traits>
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{}/{}"),
                     ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());
 ```
 ### Conventional syntax operators <a id="time.cal.operators">[[time.cal.operators]]</a>
@@ -5974,11 +5987,11 @@ the time is split. A `hh_mm_ss` models negative durations with a
 distinct `is_negative` getter that returns `true` when the input
 duration is negative. The individual duration fields always return
 non-negative durations even when `is_negative()` indicates the structure
 is representing a negative duration.
-If `Duration` is not an instance of `duration`, the program is
 ill-formed.
 ### Members <a id="time.hms.members">[[time.hms.members]]</a>
 ``` cpp
@@ -6107,11 +6120,11 @@ operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:%T}"), hms);
 ```
 [*Example 1*:
 ``` cpp
@@ -6211,11 +6224,11 @@ const time_zone* locate_zone(string_view tz_name) const;
 [*Note 1*: A `time_zone_link` specifies an alternative name for a
 `time_zone`. — *end note*]
 *Throws:* If a `const time_zone*` cannot be found as described in the
-*Returns:* clause, throws a `runtime_error`.
 [*Note 2*: On non-exceptional return, the return value is always a
 pointer to a valid `time_zone`. — *end note*]
 ``` cpp
@@ -6283,19 +6296,19 @@ const_iterator erase_after(const_iterator p);
 *Preconditions:* The iterator following `p` is dereferenceable.
 *Effects:* Erases the `tzdb` referred to by the iterator following `p`.
-*Returns:* An iterator pointing to the element following the one that
-was erased, or `end()` if no such element exists.
 *Ensures:* No pointers, references, or iterators are invalidated except
 those referring to the erased `tzdb`.
 [*Note 2*: It is not possible to erase the `tzdb` referred to by
 `begin()`. — *end note*]
 *Throws:* Nothing.
 ``` cpp
 const_iterator begin() const noexcept;
 ```
@@ -6816,32 +6829,32 @@ namespace std::chrono {
     zoned_time(const sys_time<Duration>& st);
     explicit zoned_time(TimeZonePtr z);
     explicit zoned_time(string_view name);
     template<class Duration2>
-      zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt);
     zoned_time(TimeZonePtr z,    const sys_time<Duration>& st);
     zoned_time(string_view name, const sys_time<Duration>& st);
     zoned_time(TimeZonePtr z,    const local_time<Duration>& tp);
     zoned_time(string_view name, const local_time<Duration>& tp);
     zoned_time(TimeZonePtr z,    const local_time<Duration>& tp, choose c);
     zoned_time(string_view name, const local_time<Duration>& tp, choose c);
     template<class Duration2, class TimeZonePtr2>
-      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt);
     template<class Duration2, class TimeZonePtr2>
-      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
     template<class Duration2, class TimeZonePtr2>
-      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt);
     template<class Duration2, class TimeZonePtr2>
-      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
     zoned_time& operator=(const sys_time<Duration>& st);
-    zoned_time& operator=(const local_time<Duration>& ut);
     operator sys_time<duration>() const;
     explicit operator local_time<duration>() const;
     TimeZonePtr          get_time_zone()  const;
@@ -6967,22 +6980,22 @@ zoned_time(string_view name, const sys_time<Duration>& st);
 ``` cpp
 zoned_time(TimeZonePtr z, const local_time<Duration>& tp);
 ```
-*Preconditions:* `z` refers to a time zone.
 *Constraints:*
 ``` cpp
 is_convertible_v<
   decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{})),
   sys_time<duration>>
 ```
 is `true`.
 *Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
 `zone_->to_sys(tp)`.
 ``` cpp
 zoned_time(string_view name, const local_time<Duration>& tp);
@@ -6996,22 +7009,22 @@ zoned_time(string_view name, const local_time<Duration>& tp);
 ``` cpp
 zoned_time(TimeZonePtr z, const local_time<Duration>& tp, choose c);
 ```
-*Preconditions:* `z` refers to a time zone.
 *Constraints:*
 ``` cpp
 is_convertible_v<
   decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{}, choose::earliest)),
   sys_time<duration>>
 ```
 is `true`.
 *Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
 `zone_->to_sys(tp, c)`.
 ``` cpp
 zoned_time(string_view name, const local_time<Duration>& tp, choose c);
@@ -7147,14 +7160,15 @@ template<class charT, class traits, class Duration, class TimeZonePtr>
   basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os,
                const zoned_time<Duration, TimeZonePtr>& t);
 ```
-*Effects:* Streams the value returned from `t.get_local_time()` to `os`
-using the format `"%F %T %Z"`.
-*Returns:* `os`.
 ### Class `leap_second` <a id="time.zone.leap">[[time.zone.leap]]</a>
 #### Overview <a id="time.zone.leap.overview">[[time.zone.leap.overview]]</a>
@@ -7232,11 +7246,11 @@ constexpr seconds value() const noexcept;
 ```
 *Returns:* `+1s` to indicate a positive leap second or `-1s` to indicate
 a negative leap second.
-[*Note 1*: All leap seconds inserted up through 2019 were positive leap
 seconds. — *end note*]
 #### Non-member functions <a id="time.zone.leap.nonmembers">[[time.zone.leap.nonmembers]]</a>
 ``` cpp
@@ -7382,11 +7396,11 @@ The `parse` member functions of these formatters interpret the format
 specification as a *chrono-format-spec* according to the following
 syntax:
 ``` bnf
 chrono-format-spec
-    fill-and-alignₒₚₜ widthₒₚₜ precisionₒₚₜ chrono-specsₒₚₜ
 ```
 ``` bnf
 chrono-specs
     conversion-spec
@@ -7415,23 +7429,35 @@ type one of
     'p q Q r R S t T u U V w W x X y Y z Z %'
 ```
 The productions *fill-and-align*, *width*, and *precision* are described
 in [[format.string]]. Giving a *precision* specification in the
-*chrono-format-spec* is valid only for `std::chrono::duration` types
-where the representation type `Rep` is a floating-point type. For all
-other `Rep` types, an exception of type `format_error` is thrown if the
-*chrono-format-spec* contains a *precision* specification. All ordinary
-multibyte characters represented by *literal-char* are copied unchanged
-to the output.
 Each conversion specifier *conversion-spec* is replaced by appropriate
-characters as described in [[time.format.spec]]. Some of the conversion
-specifiers depend on the locale that is passed to the formatting
-function if the latter takes one, or the global locale otherwise. If the
-formatted object does not contain the information the conversion
-specifier refers to, an exception of type `format_error` is thrown.
 The result of formatting a `std::chrono::duration` instance holding a
 negative value, or an `hh_mm_ss` object `h` for which `h.is_negative()`
 is `true`, is equivalent to the output of the corresponding positive
 value, with a `STATICALLY-WIDEN<charT>("-")` character sequence placed
@@ -7461,11 +7487,11 @@ If the type being formatted does not contain the information that the
 format flag needs, an exception of type `format_error` is thrown.
 [*Example 2*: A `duration` does not contain enough information to
 format as a `weekday`. — *end example*]
-However, if a flag refers to a “time of day” (e.g. `%H`, `%I`, `%p`,
 etc.), then a specialization of `duration` is interpreted as the time of
 day elapsed since midnight.
 **Table: Meaning of conversion specifiers** <a id="time.format.spec">[time.format.spec]</a>
@@ -7505,19 +7531,20 @@ day elapsed since midnight.
 | `%W`      | The week number of the year as a decimal number. The first Monday of the year is the first day of week `01`. Days of the same year prior to that are in week `00`. If the result is a single digit, it is prefixed with `0`. The modified command `%OW` produces the locale's alternative representation.                                                                                                                                                                                                                                                                                                      |
 | `%x`      | The locale's date representation. The modified command `%Ex` produces the locale's alternate date representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `%X`      | The locale's time representation. The modified command `%EX` produces the locale's alternate time representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `%y`      | The last two decimal digits of the year. If the result is a single digit it is prefixed by `0`. The modified command `%Oy` produces the locale's alternative representation. The modified command `%Ey` produces the locale's alternative representation of offset from `%EC` (year only).                                                                                                                                                                                                                                                                                                                     |
 | `%Y`      | The year as a decimal number. If the result is less than four digits it is left-padded with `0` to four digits. The modified command `%EY` produces the locale's alternative full year representation.                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `%z`      | The offset from UTC in the ISO 8601 format. For example `-0430` refers to 4 hours 30 minutes behind UTC. If the offset is zero, `+0000` is used. The modified commands `%Ez` and `%Oz` insert a `:` between the hours and minutes: `-04:30`. If the offset information is not available, an exception of type `format_error` is thrown. |
 | `%Z`      | The time zone abbreviation. If the time zone abbreviation is not available, an exception of type `format_error` is thrown.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `%%`      | A `%` character.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 If the *chrono-specs* is omitted, the chrono object is formatted as if
-by streaming it to `std::ostringstream os` and copying `os.str()`
-through the output iterator of the context with additional padding and
-adjustments as specified by the format specifiers.
 [*Example 3*:
 ``` cpp
 string s = format("{:=>8}", 42ms);      // value of s is "====42ms"
@@ -7636,18 +7663,18 @@ value. If `%z` (or a modified variant of `%z`) is used and
 template<class Duration, class TimeZonePtr, class charT>
 struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>
     : formatter<chrono::local-time-format-t<Duration>, charT> {
   template<class FormatContext>
     typename FormatContext::iterator
-      format(const chrono::zoned_time<Duration, TimeZonePtr>& tp, FormatContext& ctx);
 };
 ```
 ``` cpp
 template<class FormatContext>
   typename FormatContext::iterator
-    format(const chrono::zoned_time<Duration, TimeZonePtr>& tp, FormatContext& ctx);
 ```
 *Effects:* Equivalent to:
 ``` cpp
@@ -7663,94 +7690,130 @@ unqualified, so as to enable argument dependent lookup
 [[basic.lookup.argdep]]. In the following paragraphs, let `is` denote an
 object of type `basic_istream<charT, traits>` and let `I` be
 `basic_istream<charT, traits>&`, where `charT` and `traits` are template
 parameters in that context.
 ``` cpp
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp);
 ```
 *Constraints:* The expression
 ``` cpp
-from_stream(declval<basic_istream<charT, traits>&>(), fmt.c_str(), tp)
 ```
-is well-formed when treated as an unevaluated operand.
 *Returns:* A manipulator such that the expression `is >> parse(fmt, tp)`
-has type `I`, has value `is`, and calls
-`from_stream(is, fmt.c_str(), tp)`.
 ``` cpp
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           basic_string<charT, traits, Alloc>& abbrev);
 ```
 *Constraints:* The expression
 ``` cpp
-from_stream(declval<basic_istream<charT, traits>&>(), fmt.c_str(), tp, addressof(abbrev))
 ```
-is well-formed when treated as an unevaluated operand.
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, abbrev)` has type `I`, has value `is`, and calls
-`from_stream(is, fmt.c_str(), tp, addressof(abbrev))`.
 ``` cpp
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           minutes& offset);
 ```
 *Constraints:* The expression
 ``` cpp
 from_stream(declval<basic_istream<charT, traits>&>(),
- fmt.c_str(), tp,
             declval<basic_string<charT, traits, Alloc>*>(),
             &offset)
 ```
-is well-formed when treated as an unevaluated operand.
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, offset)` has type `I`, has value `is`, and calls:
 ``` cpp
 from_stream(is,
- fmt.c_str(), tp,
             static_cast<basic_string<charT, traits, Alloc>*>(nullptr),
             &offset)
 ```
 ``` cpp
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
 ```
 *Constraints:* The expression
 ``` cpp
 from_stream(declval<basic_istream<charT, traits>&>(),
- fmt.c_str(), tp, addressof(abbrev), &offset)
 ```
-is well-formed when treated as an unevaluated operand.
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, abbrev, offset)` has type `I`, has value `is`, and
-calls `from_stream(is, fmt.c_str(), tp, addressof(abbrev), &offset)`.
 All `from_stream` overloads behave as unformatted input functions,
 except that they have an unspecified effect on the value returned by
 subsequent calls to `basic_istream<>::gcount()`. Each overload takes a
 format string containing ordinary characters and flags which have
@@ -7759,33 +7822,70 @@ by `E` or `O`. During parsing each flag interprets characters as parts
 of date and time types according to  [[time.parse.spec]]. Some flags can
 be modified by a width parameter given as a positive decimal integer
 called out as `N` below which governs how many characters are parsed
 from the stream in interpreting the flag. All characters in the format
 string that are not represented in  [[time.parse.spec]], except for
-white space, are parsed unchanged from the stream. A white space
-character matches zero or more white space characters in the input
-stream.
 If the type being parsed cannot represent the information that the
 format flag refers to, `is.setstate(ios_base::failbit)` is called.
 [*Example 1*: A `duration` cannot represent a
 `weekday`. — *end example*]
-However, if a flag refers to a “time of day” (e.g. `%H`, `%I`, `%p`,
 etc.), then a specialization of `duration` is parsed as the time of day
 elapsed since midnight.
 If the `from_stream` overload fails to parse everything specified by the
 format string, or if insufficient information is parsed to specify a
 complete duration, time point, or calendrical data structure,
 `setstate(ios_base::failbit)` is called on the `basic_istream`.
-[*Note 1*: `%n`, `%t`, and a space can be combined to match a wide
-range of white-space patterns. For example, `"%n "` matches one or more
-white space characters, and `"%n%t%t"` matches one to three white space
-characters. — *end note*]
 ## Header `<ctime>` synopsis <a id="ctime.syn">[[ctime.syn]]</a>
 ``` cpp
 #define NULL see [support.types.nullptr]
@@ -7800,18 +7900,18 @@ namespace std {
   struct timespec;
   struct tm;
   clock_t clock();
   double difftime(time_t time1, time_t time0);
-  time_t mktime(struct tm* timeptr);
   time_t time(time_t* timer);
   int timespec_get(timespec* ts, int base);
-  char* asctime(const struct tm* timeptr);
   char* ctime(const time_t* timer);
- struct tm* gmtime(const time_t* timer);
- struct tm* localtime(const time_t* timer);
-  size_t strftime(char* s, size_t maxsize, const char* format, const struct tm* timeptr);
 }
 ```
 The contents of the header `<ctime>` are the same as the C standard
 library header `<time.h>`.[^1]
@@ -7824,22 +7924,25 @@ See also: ISO C 7.27
 <!-- Link reference definitions -->
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [ctime.syn]: #ctime.syn
 [filesystems]: input.md#filesystems
 [format.formatter]: utilities.md#format.formatter
 [format.string]: utilities.md#format.string
 [formatter.requirements]: utilities.md#formatter.requirements
 [intro.multithread]: basic.md#intro.multithread
-[meta.rqmts]: utilities.md#meta.rqmts
 [numeric.requirements]: numerics.md#numeric.requirements
 [over.ics.rank]: over.md#over.ics.rank
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [res.on.data.races]: library.md#res.on.data.races
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
 [time]: #time
 [time.12]: #time.12
 [time.cal]: #time.cal
 [time.cal.day]: #time.cal.day
 [time.cal.day.members]: #time.cal.day.members
@@ -7911,10 +8014,11 @@ See also: ISO C 7.27
 [time.clock.conv]: #time.clock.conv
 [time.clock.file]: #time.clock.file
 [time.clock.file.members]: #time.clock.file.members
 [time.clock.file.nonmembers]: #time.clock.file.nonmembers
 [time.clock.file.overview]: #time.clock.file.overview
 [time.clock.gps]: #time.clock.gps
 [time.clock.gps.members]: #time.clock.gps.members
 [time.clock.gps.nonmembers]: #time.clock.gps.nonmembers
 [time.clock.gps.overview]: #time.clock.gps.overview
 [time.clock.hires]: #time.clock.hires
@@ -7937,10 +8041,11 @@ See also: ISO C 7.27
 [time.duration.alg]: #time.duration.alg
 [time.duration.arithmetic]: #time.duration.arithmetic
 [time.duration.cast]: #time.duration.cast
 [time.duration.comparisons]: #time.duration.comparisons
 [time.duration.cons]: #time.duration.cons
 [time.duration.io]: #time.duration.io
 [time.duration.literals]: #time.duration.literals
 [time.duration.nonmember]: #time.duration.nonmember
 [time.duration.observer]: #time.duration.observer
 [time.duration.special]: #time.duration.special
@@ -7957,10 +8062,11 @@ See also: ISO C 7.27
 [time.point]: #time.point
 [time.point.arithmetic]: #time.point.arithmetic
 [time.point.cast]: #time.point.cast
 [time.point.comparisons]: #time.point.comparisons
 [time.point.cons]: #time.point.cons
 [time.point.nonmember]: #time.point.nonmember
 [time.point.observer]: #time.point.observer
 [time.point.special]: #time.point.special
 [time.summary]: #time.summary
 [time.syn]: #time.syn

 ## Header `<chrono>` synopsis <a id="time.syn">[[time.syn]]</a>
 ``` cpp
 #include <compare>              // see [compare.syn]
+namespace std::chrono {
   // [time.duration], class template duration
   template<class Rep, class Period = ratio<1>> class duration;
   // [time.point], class template time_point
   template<class Clock, class Duration = typename Clock::duration> class time_point;
 }
+namespace std {
   // [time.traits.specializations], common_type specializations
   template<class Rep1, class Period1, class Rep2, class Period2>
     struct common_type<chrono::duration<Rep1, Period1>,
                        chrono::duration<Rep2, Period2>>;
   template<class Clock, class Duration1, class Duration2>
     struct common_type<chrono::time_point<Clock, Duration1>,
                        chrono::time_point<Clock, Duration2>>;
+}
+namespace std::chrono {
   // [time.traits], customization traits
   template<class Rep> struct treat_as_floating_point;
   template<class Rep>
+ constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;
   template<class Rep> struct duration_values;
   template<class T> struct is_clock;
+ template<class T> constexpr bool is_clock_v = is_clock<T>::value;
   // [time.duration.nonmember], duration arithmetic
   template<class Rep1, class Period1, class Rep2, class Period2>
     constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
       operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
   constexpr year_month_weekday
     operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
+ operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
   // [time.cal.ymwdlast], class year_month_weekday_last
   class year_month_weekday_last;
   constexpr bool operator==(const year_month_weekday_last& x,
                  const zoned_time<Duration, TimeZonePtr>& t);
   // [time.zone.leap], leap second support
   class leap_second;
+  constexpr bool operator==(const leap_second& x, const leap_second& y);
+  constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);
   template<class Duration>
+    constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
+    constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
+    constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
+    constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
+    constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
+    constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
+    constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
+    constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
   template<class Duration>
+    constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
   template<class Duration>
     requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
     constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
   // [time.zone.link], class time_zone_link
     local-time-format-t<Duration>
       local_time_format(local_time<Duration> time, const string* abbrev = nullptr,
                         const seconds* offset_sec = nullptr);
 }
+namespace std {
   template<class Rep, class Period, class charT>
     struct formatter<chrono::duration<Rep, Period>, charT>;
   template<class Duration, class charT>
     struct formatter<chrono::sys_time<Duration>, charT>;
   template<class Duration, class charT>
     struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;
   template<class charT> struct formatter<chrono::sys_info, charT>;
   template<class charT> struct formatter<chrono::local_info, charT>;
   template<class Duration, class TimeZonePtr, class charT>
     struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
+}
+namespace std::chrono {
   // [time.parse], parsing
+  template<class charT, class Parsable>
+    unspecified
+     parse(const charT* fmt, Parsable& tp);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
+ parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
+ parse(const charT* fmt, Parsable& tp,
+            basic_string<charT, traits, Alloc>& abbrev);
+  template<class charT, class traits, class Alloc, class Parsable>
+    unspecified
+      parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
             basic_string<charT, traits, Alloc>& abbrev);
+  template<class charT, class Parsable>
+    unspecified
+      parse(const charT* fmt, Parsable& tp, minutes& offset);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
+ parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
             minutes& offset);
   template<class charT, class traits, class Alloc, class Parsable>
     unspecified
+ parse(const charT* fmt, Parsable& tp,
+            basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
+  template<class charT, class traits, class Alloc, class Parsable>
+    unspecified
+      parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
             basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
   // calendrical constants
   inline constexpr last_spec last{};
   inline constexpr month October{10};
   inline constexpr month November{11};
   inline constexpr month December{12};
 }
+namespace std::inline literals::inline chrono_literals {
   // [time.duration.literals], suffixes for duration literals
   constexpr chrono::hours                                 operator""h(unsigned long long);
   constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double);
   constexpr chrono::minutes                             operator""min(unsigned long long);
   constexpr chrono::day  operator""d(unsigned long long d) noexcept;
   // [time.cal.year.nonmembers], non-member functions
   constexpr chrono::year operator""y(unsigned long long y) noexcept;
 }
+namespace std::chrono {
   using namespace literals::chrono_literals;
 }
 ```
 ## *Cpp17Clock* requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
 by a given clock and the SI definition is a measure of the quality of
 implementation. — *end note*]
 A type `TC` meets the *Cpp17TrivialClock* requirements if:
+- `TC` meets the *Cpp17Clock* requirements,
 - the types `TC::rep`, `TC::duration`, and `TC::time_point` meet the
   *Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) and
+  *Cpp17LessThanComparable* ([[cpp17.lessthancomparable]]) and
+ *Cpp17Swappable* [[swappable.requirements]] requirements and the
+  requirements of numeric types [[numeric.requirements]],
   \[*Note 3*: This means, in particular, that operations on these types
   will not throw exceptions. — *end note*]
 - the function `TC::now()` does not throw exceptions, and
 - the type `TC::time_point::clock` meets the *Cpp17TrivialClock*
   requirements, recursively.
 ## Time-related traits <a id="time.traits">[[time.traits]]</a>
   };
 ```
 The `duration` template uses the `duration_values` trait to construct
 special values of the duration’s representation (`Rep`). This is done
+because the representation can be a class type with behavior that
 requires some other implementation to return these special values. In
 that case, the author of that class type should specialize
 `duration_values` to return the indicated values.
 ``` cpp
 static constexpr Rep zero() noexcept;
 ```
 *Returns:* `Rep(0)`.
+[*Note 1*: `Rep(0)` is specified instead of `Rep()` because `Rep()` can
 have some other meaning, such as an uninitialized value. — *end note*]
 *Remarks:* The value returned shall be the additive identity.
 ``` cpp
 [*Note 2*: The `typedef` name `type` is a synonym for the `duration`
 with the largest tick `period` possible where both `duration` arguments
 will convert to it without requiring a division operation. The
 representation of this type is intended to be able to hold any value
 resulting from this conversion with no truncation error, although
+floating-point durations can have round-off errors. — *end note*]
 ``` cpp
 template<class Clock, class Duration1, class Duration2>
   struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
     using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
 *Cpp17Clock* unless it meets all of the following conditions:
 - the *qualified-id*s `T::rep`, `T::period`, `T::duration`, and
   `T::time_point` are valid and each denotes a type [[temp.deduct]],
 - the expression `T::is_steady` is well-formed when treated as an
+  unevaluated operand [[term.unevaluated.operand]],
 - the expression `T::now()` is well-formed when treated as an
   unevaluated operand.
 The behavior of a program that adds specializations for `is_clock` is
 undefined.
 ## Class template `duration` <a id="time.duration">[[time.duration]]</a>
+### General <a id="time.duration.general">[[time.duration.general]]</a>
 A `duration` type measures time between two points in time
 (`time_point`s). A `duration` has a representation which holds a count
 of ticks and a tick period. The tick period is the amount of time which
 occurs from one tick to the next, in units of seconds. It is expressed
 as a rational constant using the template `ratio`.
 Members of `duration` do not throw exceptions other than those thrown by
 the indicated operations on their representations.
 The defaulted copy constructor of duration shall be a constexpr function
 if and only if the required initialization of the member `rep_` for copy
+and move, respectively, would be constexpr-suitable [[dcl.constexpr]].
 [*Example 1*:
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<int, milli> d(3.5);        // error
 ```
 — *end example*]
+*Effects:* Initializes `rep_` with `r`.
 ``` cpp
 template<class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
   `"d"`.
 - Otherwise, if `Period::type::den == 1`, *`units-suffix`* is
   `"[`*`num`*`]s"`.
 - Otherwise, *`units-suffix`* is `"[`*`num`*`/`*`den`*`]s"`.
+In the list above, the use of *`num`* and *`den`* refers to the static
 data members of `Period::type`, which are converted to arrays of `charT`
 using a decimal conversion with no leading zeroes.
 *Returns:* `os`.
                 minutes* offset = nullptr);
 ```
 *Effects:* Attempts to parse the input stream `is` into the duration `d`
 using the format flags given in the NTCTS `fmt` as specified in
+[[time.parse]]. If the parse fails to decode a valid duration,
+`is.setstate(ios_base::failbit)` is called and `d` is not modified. If
+`%Z` is used and successfully parsed, that value will be assigned to
+`*abbrev` if `abbrev` is non-null. If `%z` (or a modified variant) is
+used and successfully parsed, that value will be assigned to `*offset`
+if `offset` is non-null.
 *Returns:* `is`.
 ## Class template `time_point` <a id="time.point">[[time.point]]</a>
+### General <a id="time.point.general">[[time.point.general]]</a>
 ``` cpp
 namespace std::chrono {
   template<class Clock, class Duration = typename Clock::duration>
   class time_point {
   public:
     static constexpr time_point max() noexcept;
   };
 }
 ```
+If `Duration` is not a specialization of `duration`, the program is
 ill-formed.
 ### Constructors <a id="time.point.cons">[[time.point.cons]]</a>
 ``` cpp
 *Returns:*
 `time_point<Clock, ToDuration>(round<ToDuration>(tp.time_since_epoch()))`.
 ## Clocks <a id="time.clock">[[time.clock]]</a>
+### General <a id="time.clock.general">[[time.clock.general]]</a>
+The types defined in [[time.clock]] meet the *Cpp17TrivialClock*
 requirements [[time.clock.req]] unless otherwise specified.
 ### Class `system_clock` <a id="time.clock.system">[[time.clock.system]]</a>
 #### Overview <a id="time.clock.system.overview">[[time.clock.system.overview]]</a>
 `false`, and `Duration{1} < days{1}` is `true`.
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), tp);
 ```
 [*Example 1*:
 ``` cpp
 [*Example 1*:
 `clock_cast<utc_clock>(sys_seconds{sys_days{1970y/January/1}}).time_since_epoch()`
 is `0s`.
 `clock_cast<utc_clock>(sys_seconds{sys_days{2000y/January/1}}).time_since_epoch()`
+is `946'684'822s`,
+which is `10'957 * 86'400s + 22s`.
  — *end example*]
 `utc_clock` is not a *Cpp17TrivialClock* unless the implementation can
 guarantee that `utc_clock::now()` does not propagate an exception.
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
 ```
 *Returns:*
 ``` cpp
+utc_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 315964809s
 ```
 [*Note 1*:
 ``` cpp
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), t);
 ```
 [*Example 1*:
 ``` cpp
 requirements [[time.clock.req]], and using a signed arithmetic type for
 `file_clock::rep`. `file_clock` is used to create the `time_point`
 system used for `file_time_type` [[filesystems]]. Its epoch is
 unspecified, and `noexcept(file_clock::now())` is `true`.
+[*Note 1*: The type that `file_clock` denotes can be in a different
 namespace than `std::chrono`, such as `std::filesystem`. — *end note*]
 #### Member functions <a id="time.clock.file.members">[[time.clock.file.members]]</a>
 The type denoted by `file_clock` provides precisely one of the following
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), t);
 ```
 ``` cpp
 template<class charT, class traits, class Duration, class Alloc = allocator<charT>>
   basic_istream<charT, traits>&
     -> decltype(SourceClock::to_sys(t));
 ```
 *Constraints:* `SourceClock::to_sys(t)` is well-formed.
+*Mandates:* `SourceClock::to_sys(t)` returns a `sys_time<Duration2>` for
+some type `Duration2` [[time.point.general]].
 *Returns:* `SourceClock::to_sys(t)`.
 ``` cpp
 template<class DestClock>
 ```
 *Constraints:* `DestClock::from_sys(t)` is well-formed.
 *Mandates:* `DestClock::from_sys(t)` returns a
+`time_point<DestClock, Duration2>` for some type `Duration2`
+[[time.point.general]].
 *Returns:* `DestClock::from_sys(t)`.
 #### Conversions between `utc_clock` and other clocks <a id="time.clock.cast.utc">[[time.clock.cast.utc]]</a>
     -> decltype(SourceClock::to_utc(t));
 ```
 *Constraints:* `SourceClock::to_utc(t)` is well-formed.
+*Mandates:* `SourceClock::to_utc(t)` returns a `utc_time<Duration2>` for
+some type `Duration2` [[time.point.general]].
 *Returns:* `SourceClock::to_utc(t)`.
 ``` cpp
 template<class DestClock>
 ```
 *Constraints:* `DestClock::from_utc(t)` is well-formed.
 *Mandates:* `DestClock::from_utc(t)` returns a
+`time_point<DestClock, Duration2>` for some type `Duration2`
+[[time.point.general]].
 *Returns:* `DestClock::from_utc(t)`.
 #### Function template `clock_cast` <a id="time.clock.cast.fn">[[time.clock.cast.fn]]</a>
 *Effects:* Equivalent to:
 ``` cpp
 return os << (m.ok() ?
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%b}"), m) :
   format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid month"),
          static_cast<unsigned>(m)));
 ```
 ``` cpp
 ```
 *Returns:* `*this`.
 ``` cpp
+constexpr year operator-() const noexcept;
 ```
 *Returns:* `year{-y_}`.
 ``` cpp
 ``` cpp
 constexpr year operator+(const year& x, const years& y) noexcept;
 ```
+*Returns:* `year{int{x} + static_cast<int>(y.count())}`.
 ``` cpp
 constexpr year operator+(const years& x, const year& y) noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 return os << (wd.ok() ?
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%a}"), wd) :
   format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid weekday"),
          static_cast<unsigned>(wd.wd_)));
 ```
 ``` cpp
 *Effects:* Equivalent to:
 ``` cpp
 auto i = wdi.index();
 return os << (i >= 1 && i <= 5 ?
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[{}]"), wdi.weekday(), i) :
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[{} is not a valid index]"),
          wdi.weekday(), i));
 ```
 ### Class `weekday_last` <a id="time.cal.wdlast">[[time.cal.wdlast]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}[last]"), wdl.weekday());
 ```
 ### Class `month_day` <a id="time.cal.md">[[time.cal.md]]</a>
 #### Overview <a id="time.cal.md.overview">[[time.cal.md.overview]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{}"),
                     md.month(), md.day());
 ```
 ``` cpp
 template<class charT, class traits, class Alloc = allocator<charT>>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/last"), mdl.month());
 ```
 ### Class `month_weekday` <a id="time.cal.mwd">[[time.cal.mwd]]</a>
 #### Overview <a id="time.cal.mwd.overview">[[time.cal.mwd.overview]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
                     mwd.month(), mwd.weekday_indexed());
 ```
 ### Class `month_weekday_last` <a id="time.cal.mwdlast">[[time.cal.mwdlast]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L}/{:L}"),
                     mwdl.month(), mwdl.weekday_last());
 ```
 ### Class `year_month` <a id="time.cal.ym">[[time.cal.ym]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"),
                     ym.year(), ym.month());
 ```
 ``` cpp
 template<class charT, class traits, class Alloc = allocator<charT>>
 *Effects:* Initializes `y_` with `ymdl.year()`, `m_` with
 `ymdl.month()`, and `d_` with `ymdl.day()`.
 [*Note 1*: This conversion from `year_month_day_last` to
+`year_month_day` can be more efficient than converting a
 `year_month_day_last` to a `sys_days`, and then converting that
 `sys_days` to a `year_month_day`. — *end note*]
 ``` cpp
 constexpr year_month_day(const sys_days& dp) noexcept;
 ```
 *Returns:* `(ymd.year() + dy) / ymd.month() / ymd.day()`.
 [*Note 2*: If `ymd.month()` is February and `ymd.day()` is not in the
+range \[`1d`, `28d`\], `ok()` can return `false` for the resultant
 `year_month_day`. — *end note*]
 ``` cpp
 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
 ```
 *Returns:* If `ok()` is `true`, returns a `day` representing the last
 day of the (`year`, `month`) pair represented by `*this`. Otherwise, the
 returned value is unspecified.
+[*Note 1*: This value might be computed on demand. — *end note*]
 ``` cpp
 constexpr operator sys_days() const noexcept;
 ```
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}"),
                     ymdl.year(), ymdl.month_day_last());
 ```
 ### Class `year_month_weekday` <a id="time.cal.ymwd">[[time.cal.ymwd]]</a>
 ```
 *Effects:* Constructs an object of type `year_month_weekday` which
 corresponds to the date represented by `dp`.
+*Remarks:* For any value `ymwd` of type `year_month_weekday` for which
+`ymwd.ok()` is `true`, `ymwd == year_month_weekday{sys_days{ymwd}}` is
 `true`.
 ``` cpp
 constexpr explicit year_month_weekday(const local_days& dp) noexcept;
 ```
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"),
                     ymwd.year(), ymwd.month(), ymwd.weekday_indexed());
 ```
 ### Class `year_month_weekday_last` <a id="time.cal.ymwdlast">[[time.cal.ymwdlast]]</a>
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{}/{:L}/{:L}"),
                     ymwdl.year(), ymwdl.month(), ymwdl.weekday_last());
 ```
 ### Conventional syntax operators <a id="time.cal.operators">[[time.cal.operators]]</a>
 distinct `is_negative` getter that returns `true` when the input
 duration is negative. The individual duration fields always return
 non-negative durations even when `is_negative()` indicates the structure
 is representing a negative duration.
+If `Duration` is not a specialization of `duration`, the program is
 ill-formed.
 ### Members <a id="time.hms.members">[[time.hms.members]]</a>
 ``` cpp
 ```
 *Effects:* Equivalent to:
 ``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%T}"), hms);
 ```
 [*Example 1*:
 ``` cpp
 [*Note 1*: A `time_zone_link` specifies an alternative name for a
 `time_zone`. — *end note*]
 *Throws:* If a `const time_zone*` cannot be found as described in the
+*Returns:* element, throws a `runtime_error`.
 [*Note 2*: On non-exceptional return, the return value is always a
 pointer to a valid `time_zone`. — *end note*]
 ``` cpp
 *Preconditions:* The iterator following `p` is dereferenceable.
 *Effects:* Erases the `tzdb` referred to by the iterator following `p`.
 *Ensures:* No pointers, references, or iterators are invalidated except
 those referring to the erased `tzdb`.
 [*Note 2*: It is not possible to erase the `tzdb` referred to by
 `begin()`. — *end note*]
+*Returns:* An iterator pointing to the element following the one that
+was erased, or `end()` if no such element exists.
 *Throws:* Nothing.
 ``` cpp
 const_iterator begin() const noexcept;
 ```
     zoned_time(const sys_time<Duration>& st);
     explicit zoned_time(TimeZonePtr z);
     explicit zoned_time(string_view name);
     template<class Duration2>
+      zoned_time(const zoned_time<Duration2, TimeZonePtr>& y);
     zoned_time(TimeZonePtr z,    const sys_time<Duration>& st);
     zoned_time(string_view name, const sys_time<Duration>& st);
     zoned_time(TimeZonePtr z,    const local_time<Duration>& tp);
     zoned_time(string_view name, const local_time<Duration>& tp);
     zoned_time(TimeZonePtr z,    const local_time<Duration>& tp, choose c);
     zoned_time(string_view name, const local_time<Duration>& tp, choose c);
     template<class Duration2, class TimeZonePtr2>
+      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& y);
     template<class Duration2, class TimeZonePtr2>
+      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& y, choose);
     template<class Duration2, class TimeZonePtr2>
+      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& y);
     template<class Duration2, class TimeZonePtr2>
+      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& y, choose c);
     zoned_time& operator=(const sys_time<Duration>& st);
+    zoned_time& operator=(const local_time<Duration>& lt);
     operator sys_time<duration>() const;
     explicit operator local_time<duration>() const;
     TimeZonePtr          get_time_zone()  const;
 ``` cpp
 zoned_time(TimeZonePtr z, const local_time<Duration>& tp);
 ```
 *Constraints:*
 ``` cpp
 is_convertible_v<
   decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{})),
   sys_time<duration>>
 ```
 is `true`.
+*Preconditions:* `z` refers to a time zone.
 *Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
 `zone_->to_sys(tp)`.
 ``` cpp
 zoned_time(string_view name, const local_time<Duration>& tp);
 ``` cpp
 zoned_time(TimeZonePtr z, const local_time<Duration>& tp, choose c);
 ```
 *Constraints:*
 ``` cpp
 is_convertible_v<
   decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{}, choose::earliest)),
   sys_time<duration>>
 ```
 is `true`.
+*Preconditions:* `z` refers to a time zone.
 *Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
 `zone_->to_sys(tp, c)`.
 ``` cpp
 zoned_time(string_view name, const local_time<Duration>& tp, choose c);
   basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os,
                const zoned_time<Duration, TimeZonePtr>& t);
 ```
+*Effects:* Equivalent to:
+``` cpp
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T %Z}"), t);
+```
 ### Class `leap_second` <a id="time.zone.leap">[[time.zone.leap]]</a>
 #### Overview <a id="time.zone.leap.overview">[[time.zone.leap.overview]]</a>
 ```
 *Returns:* `+1s` to indicate a positive leap second or `-1s` to indicate
 a negative leap second.
+[*Note 1*: All leap seconds inserted up through 2022 were positive leap
 seconds. — *end note*]
 #### Non-member functions <a id="time.zone.leap.nonmembers">[[time.zone.leap.nonmembers]]</a>
 ``` cpp
 specification as a *chrono-format-spec* according to the following
 syntax:
 ``` bnf
 chrono-format-spec
+    fill-and-alignₒₚₜ widthₒₚₜ precisionₒₚₜ 'L'ₒₚₜ chrono-specsₒₚₜ
 ```
 ``` bnf
 chrono-specs
     conversion-spec
     'p q Q r R S t T u U V w W x X y Y z Z %'
 ```
 The productions *fill-and-align*, *width*, and *precision* are described
 in [[format.string]]. Giving a *precision* specification in the
+*chrono-format-spec* is valid only for types that are specializations of
+`std::chrono::duration` for which the nested *typedef-name* `rep`
+denotes a floating-point type. For all other types, an exception of type
+`format_error` is thrown if the *chrono-format-spec* contains a
+*precision* specification. All ordinary multibyte characters represented
+by *literal-char* are copied unchanged to the output.
+A *formatting locale* is an instance of `locale` used by a formatting
+function, defined as
+- the `"C"` locale if the `L` option is not present in
+  *chrono-format-spec*, otherwise
+- the locale passed to the formatting function if any, otherwise
+- the global locale.
 Each conversion specifier *conversion-spec* is replaced by appropriate
+characters as described in [[time.format.spec]]; the formats specified
+in ISO 8601:2004 shall be used where so described. Some of the
+conversion specifiers depend on the formatting locale. If the string
+literal encoding is a Unicode encoding form and the locale is among an
+*implementation-defined* set of locales, each replacement that depends
+on the locale is performed as if the replacement character sequence is
+converted to the string literal encoding. If the formatted object does
+not contain the information the conversion specifier refers to, an
+exception of type `format_error` is thrown.
 The result of formatting a `std::chrono::duration` instance holding a
 negative value, or an `hh_mm_ss` object `h` for which `h.is_negative()`
 is `true`, is equivalent to the output of the corresponding positive
 value, with a `STATICALLY-WIDEN<charT>("-")` character sequence placed
 format flag needs, an exception of type `format_error` is thrown.
 [*Example 2*: A `duration` does not contain enough information to
 format as a `weekday`. — *end example*]
+However, if a flag refers to a “time of day” (e.g., `%H`, `%I`, `%p`,
 etc.), then a specialization of `duration` is interpreted as the time of
 day elapsed since midnight.
 **Table: Meaning of conversion specifiers** <a id="time.format.spec">[time.format.spec]</a>
 | `%W`      | The week number of the year as a decimal number. The first Monday of the year is the first day of week `01`. Days of the same year prior to that are in week `00`. If the result is a single digit, it is prefixed with `0`. The modified command `%OW` produces the locale's alternative representation.                                                                                                                                                                                                                                                                                                      |
 | `%x`      | The locale's date representation. The modified command `%Ex` produces the locale's alternate date representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `%X`      | The locale's time representation. The modified command `%EX` produces the locale's alternate time representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `%y`      | The last two decimal digits of the year. If the result is a single digit it is prefixed by `0`. The modified command `%Oy` produces the locale's alternative representation. The modified command `%Ey` produces the locale's alternative representation of offset from `%EC` (year only).                                                                                                                                                                                                                                                                                                                     |
 | `%Y`      | The year as a decimal number. If the result is less than four digits it is left-padded with `0` to four digits. The modified command `%EY` produces the locale's alternative full year representation.                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%z`      | The offset from UTC in the ISO 8601:2004 format. For example `-0430` refers to 4 hours 30 minutes behind UTC. If the offset is zero, `+0000` is used. The modified commands `%Ez` and `%Oz` insert a `:` between the hours and minutes: `-04:30`. If the offset information is not available, an exception of type `format_error` is thrown. |
 | `%Z`      | The time zone abbreviation. If the time zone abbreviation is not available, an exception of type `format_error` is thrown.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `%%`      | A `%` character.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 If the *chrono-specs* is omitted, the chrono object is formatted as if
+by streaming it to `basic_ostringstream<charT> os` with the formatting
+locale imbued and copying `os.str()` through the output iterator of the
+context with additional padding and adjustments as specified by the
+format specifiers.
 [*Example 3*:
 ``` cpp
 string s = format("{:=>8}", 42ms);      // value of s is "====42ms"
 template<class Duration, class TimeZonePtr, class charT>
 struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>
     : formatter<chrono::local-time-format-t<Duration>, charT> {
   template<class FormatContext>
     typename FormatContext::iterator
+      format(const chrono::zoned_time<Duration, TimeZonePtr>& tp, FormatContext& ctx) const;
 };
 ```
 ``` cpp
 template<class FormatContext>
   typename FormatContext::iterator
+    format(const chrono::zoned_time<Duration, TimeZonePtr>& tp, FormatContext& ctx) const;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 [[basic.lookup.argdep]]. In the following paragraphs, let `is` denote an
 object of type `basic_istream<charT, traits>` and let `I` be
 `basic_istream<charT, traits>&`, where `charT` and `traits` are template
 parameters in that context.
+*Recommended practice:* Implementations should make it difficult to
+accidentally store or use a manipulator that may contain a dangling
+reference to a format string, for example by making the manipulators
+produced by `parse` immovable and preventing stream extraction into an
+lvalue of such a manipulator type.
 ``` cpp
+template<class charT, class Parsable>
+  unspecified
+    parse(const charT* fmt, Parsable& tp);
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp);
 ```
+Let F be `fmt` for the first overload and `fmt.c_str()` for the second
+overload. Let `traits` be `char_traits<charT>` for the first overload.
 *Constraints:* The expression
 ``` cpp
+from_stream(declval<basic_istream<charT, traits>&>(), F, tp)
 ```
+is well-formed when treated as an unevaluated
+operand [[term.unevaluated.operand]].
 *Returns:* A manipulator such that the expression `is >> parse(fmt, tp)`
+has type `I`, has value `is`, and calls `from_stream(is, `F`, tp)`.
 ``` cpp
+template<class charT, class traits, class Alloc, class Parsable>
+  unspecified
+    parse(const charT* fmt, Parsable& tp,
+          basic_string<charT, traits, Alloc>& abbrev);
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           basic_string<charT, traits, Alloc>& abbrev);
 ```
+Let F be `fmt` for the first overload and `fmt.c_str()` for the second
+overload.
 *Constraints:* The expression
 ``` cpp
+from_stream(declval<basic_istream<charT, traits>&>(), F, tp, addressof(abbrev))
 ```
+is well-formed when treated as an unevaluated
+operand [[term.unevaluated.operand]].
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, abbrev)` has type `I`, has value `is`, and calls
+`from_stream(is, `F`, tp, addressof(abbrev))`.
 ``` cpp
+template<class charT, class Parsable>
+  unspecified
+    parse(const charT* fmt, Parsable& tp, minutes& offset);
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           minutes& offset);
 ```
+Let F be `fmt` for the first overload and `fmt.c_str()` for the second
+overload. Let `traits` be `char_traits<charT>` and `Alloc` be
+`allocator<charT>` for the first overload.
 *Constraints:* The expression
 ``` cpp
 from_stream(declval<basic_istream<charT, traits>&>(),
+ F, tp,
             declval<basic_string<charT, traits, Alloc>*>(),
             &offset)
 ```
+is well-formed when treated as an unevaluated
+operand [[term.unevaluated.operand]].
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, offset)` has type `I`, has value `is`, and calls:
 ``` cpp
 from_stream(is,
+ F, tp,
             static_cast<basic_string<charT, traits, Alloc>*>(nullptr),
             &offset)
 ```
 ``` cpp
+template<class charT, class traits, class Alloc, class Parsable>
+  unspecified
+    parse(const charT* fmt, Parsable& tp,
+          basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
 template<class charT, class traits, class Alloc, class Parsable>
   unspecified
     parse(const basic_string<charT, traits, Alloc>& fmt, Parsable& tp,
           basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
 ```
+Let F be `fmt` for the first overload and `fmt.c_str()` for the second
+overload.
 *Constraints:* The expression
 ``` cpp
 from_stream(declval<basic_istream<charT, traits>&>(),
+ F, tp, addressof(abbrev), &offset)
 ```
+is well-formed when treated as an unevaluated
+operand [[term.unevaluated.operand]].
 *Returns:* A manipulator such that the expression
 `is >> parse(fmt, tp, abbrev, offset)` has type `I`, has value `is`, and
+calls `from_stream(is, `F`, tp, addressof(abbrev), &offset)`.
 All `from_stream` overloads behave as unformatted input functions,
 except that they have an unspecified effect on the value returned by
 subsequent calls to `basic_istream<>::gcount()`. Each overload takes a
 format string containing ordinary characters and flags which have
 of date and time types according to  [[time.parse.spec]]. Some flags can
 be modified by a width parameter given as a positive decimal integer
 called out as `N` below which governs how many characters are parsed
 from the stream in interpreting the flag. All characters in the format
 string that are not represented in  [[time.parse.spec]], except for
+whitespace, are parsed unchanged from the stream. A whitespace character
+matches zero or more whitespace characters in the input stream.
 If the type being parsed cannot represent the information that the
 format flag refers to, `is.setstate(ios_base::failbit)` is called.
 [*Example 1*: A `duration` cannot represent a
 `weekday`. — *end example*]
+However, if a flag refers to a “time of day” (e.g., `%H`, `%I`, `%p`,
 etc.), then a specialization of `duration` is parsed as the time of day
 elapsed since midnight.
 If the `from_stream` overload fails to parse everything specified by the
 format string, or if insufficient information is parsed to specify a
 complete duration, time point, or calendrical data structure,
 `setstate(ios_base::failbit)` is called on the `basic_istream`.
+**Table: Meaning of `parse` flags** <a id="time.parse.spec">[time.parse.spec]</a>
+| Flag | Parsed value                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `%a` | The locale's full or abbreviated case-insensitive weekday name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `%A` | Equivalent to `%a`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%b` | The locale's full or abbreviated case-insensitive month name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `%B` | Equivalent to `%b`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%c` | The locale's date and time representation. The modified command `%Ec` interprets the locale's alternate date and time representation.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `%C` | The century as a decimal number. The modified command `%*N*C` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%EC` interprets the locale's alternative representation of the century.                                                                                                                                                                                                                                                                 |
+| `%d` | The day of the month as a decimal number. The modified command `%*N*d` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%Od` interprets the locale's alternative representation of the day of the month.                                                                                                                                                                                                                                               |
+| `%D` | Equivalent to `%m/%d/%y`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `%e` | Equivalent to `%d` and can be modified like `%d`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `%F` | Equivalent to `%Y-%m-%d`. If modified with a width `*N*`, the width is applied to only `%Y`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `%g` | The last two decimal digits of the ISO week-based year. The modified command `%*N*g` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required.                                                                                                                                                                                                                                                                                                                                        |
+| `%G` | The ISO week-based year as a decimal number. The modified command `%*N*G` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 4. Leading zeroes are permitted but not required.                                                                                                                                                                                                                                                                                                                                                   |
+| `%h` | Equivalent to `%b`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%H` | The hour (24-hour clock) as a decimal number. The modified command `%*N*H` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%OH` interprets the locale's alternative representation.                                                                                                                                                                                                                                                                   |
+| `%I` | The hour (12-hour clock) as a decimal number. The modified command `%*N*I` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%OI` interprets the locale's alternative representation.                                                                                                                                                                                                                                                                   |
+| `%j` | If the type being parsed is a specialization of `duration`, a decimal number of `days`. Otherwise, the day of the year as a decimal number. Jan 1 is `1`. In either case, the modified command `%*N*j` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 3. Leading zeroes are permitted but not required.                                                                                                                                                                                                                      |
+| `%m` | The month as a decimal number. Jan is `1`. The modified command `%*N*m` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%Om` interprets the locale's alternative representation.                                                                                                                                                                                                                                                                      |
+| `%M` | The minutes as a decimal number. The modified command `%*N*M` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%OM` interprets the locale's alternative representation.                                                                                                                                                                                                                                                                                |
+| `%n` | Matches one whitespace character. *`%n`, `%t`, and a space can be combined to match a wide range of whitespace patterns. For example, `"%n "` matches one or more whitespace characters, and `"%n%t%t"` matches one to three whitespace characters.*                                                                                                                                                                                                                                                                                                                        |
+| `%p` | The locale's equivalent of the AM/PM designations associated with a 12-hour clock.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `%r` | The locale's 12-hour clock time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `%R` | Equivalent to `%H:%M`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `%S` | The seconds as a decimal number. The modified command `%*N*S` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2 if the input time has a precision convertible to seconds. Otherwise the default width is determined by the decimal precision of the input and the field is interpreted as a `long double` in a fixed format. If encountered, the locale determines the decimal point character. Leading zeroes are permitted but not required. The modified command `%OS` interprets the locale's alternative representation. |
+| `%t` | Matches zero or one whitespace characters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `%T` | Equivalent to `%H:%M:%S`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `%u` | The ISO weekday as a decimal number (`1`-`7`), where Monday is `1`. The modified command `%*N*u` specifies the maximum number of characters to read. If `*N*` is not specified, the default is `1`. Leading zeroes are permitted but not required.                                                                                                                                                                                                                                                                                                                          |
+| `%U` | The week number of the year as a decimal number. The first Sunday of the year is the first day of week `01`. Days of the same year prior to that are in week `00`. The modified command `%*N*U` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%OU` interprets the locale's alternative representation.                                                                                                                                              |
+| `%V` | The ISO week-based week number as a decimal number. The modified command `%*N*V` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required.                                                                                                                                                                                                                                                                                                                                            |
+| `%w` | The weekday as a decimal number (`0`-`6`), where Sunday is `0`. The modified command `%*N*w` specifies the maximum number of characters to read. If `*N*` is not specified, the default is `1`. Leading zeroes are permitted but not required. The modified command `%Ow` interprets the locale's alternative representation.                                                                                                                                                                                                                                               |
+| `%W` | The week number of the year as a decimal number. The first Monday of the year is the first day of week `01`. Days of the same year prior to that are in week `00`. The modified command `%*N*W` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified command `%OW` interprets the locale's alternative representation.                                                                                                                                              |
+| `%x` | The locale's date representation. The modified command `%Ex` interprets the locale's alternate date representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%X` | The locale's time representation. The modified command `%EX` interprets the locale's alternate time representation.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `%y` | The last two decimal digits of the year. If the century is not otherwise specified (e.g., with `%C`), values in the range {[}`69`, `99`{]} are presumed to refer to the years 1969 to 1999, and values in the range {[}`00`, `68`{]} are presumed to refer to the years 2000 to 2068. The modified command `%*N*y` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 2. Leading zeroes are permitted but not required. The modified commands `%Ey` and `%Oy` interpret the locale's alternative representation.                 |
+| `%Y` | The year as a decimal number. The modified command `%*N*Y` specifies the maximum number of characters to read. If `*N*` is not specified, the default is 4. Leading zeroes are permitted but not required. The modified command `%EY` interprets the locale's alternative representation.                                                                                                                                                                                                                                                                                   |
+| `%z` | The offset from UTC in the format `[+|-]hh[mm]`. For example `-0430` refers to 4 hours 30 minutes behind UTC, and `04` refers to 4 hours ahead of UTC. The modified commands `%Ez` and `%Oz` parse a `:` between the hours and minutes and render leading zeroes on the hour field optional: `[+|-]h[h][:mm]`. For example `-04:30` refers to 4 hours 30 minutes behind UTC, and `4` refers to 4 hours ahead of UTC.                                                                                                                                                        |
+| `%Z` | The time zone abbreviation or name. A single word is parsed. This word can only contain characters from the basic character set [[lex.charset]] that are alphanumeric, or one of `'_'`, `'/'`, `'-'`, or `'+'`.                                                                                                                                                                                                                                                                                                                                                             |
+| `%%` | A `%` character is extracted.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 ## Header `<ctime>` synopsis <a id="ctime.syn">[[ctime.syn]]</a>
 ``` cpp
 #define NULL see [support.types.nullptr]
   struct timespec;
   struct tm;
   clock_t clock();
   double difftime(time_t time1, time_t time0);
+  time_t mktime(tm* timeptr);
   time_t time(time_t* timer);
   int timespec_get(timespec* ts, int base);
+  char* asctime(const tm* timeptr);
   char* ctime(const time_t* timer);
+  tm* gmtime(const time_t* timer);
+  tm* localtime(const time_t* timer);
+  size_t strftime(char* s, size_t maxsize, const char* format, const tm* timeptr);
 }
 ```
 The contents of the header `<ctime>` are the same as the C standard
 library header `<time.h>`.[^1]
 <!-- Link reference definitions -->
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [cpp17.equalitycomparable]: #cpp17.equalitycomparable
 [cpp17.lessthancomparable]: #cpp17.lessthancomparable
 [ctime.syn]: #ctime.syn
+[dcl.constexpr]: dcl.md#dcl.constexpr
 [filesystems]: input.md#filesystems
 [format.formatter]: utilities.md#format.formatter
 [format.string]: utilities.md#format.string
 [formatter.requirements]: utilities.md#formatter.requirements
 [intro.multithread]: basic.md#intro.multithread
+[lex.charset]: lex.md#lex.charset
+[meta.rqmts]: meta.md#meta.rqmts
 [numeric.requirements]: numerics.md#numeric.requirements
 [over.ics.rank]: over.md#over.ics.rank
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [res.on.data.races]: library.md#res.on.data.races
 [swappable.requirements]: library.md#swappable.requirements
 [temp.deduct]: temp.md#temp.deduct
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [time]: #time
 [time.12]: #time.12
 [time.cal]: #time.cal
 [time.cal.day]: #time.cal.day
 [time.cal.day.members]: #time.cal.day.members
 [time.clock.conv]: #time.clock.conv
 [time.clock.file]: #time.clock.file
 [time.clock.file.members]: #time.clock.file.members
 [time.clock.file.nonmembers]: #time.clock.file.nonmembers
 [time.clock.file.overview]: #time.clock.file.overview
+[time.clock.general]: #time.clock.general
 [time.clock.gps]: #time.clock.gps
 [time.clock.gps.members]: #time.clock.gps.members
 [time.clock.gps.nonmembers]: #time.clock.gps.nonmembers
 [time.clock.gps.overview]: #time.clock.gps.overview
 [time.clock.hires]: #time.clock.hires
 [time.duration.alg]: #time.duration.alg
 [time.duration.arithmetic]: #time.duration.arithmetic
 [time.duration.cast]: #time.duration.cast
 [time.duration.comparisons]: #time.duration.comparisons
 [time.duration.cons]: #time.duration.cons
+[time.duration.general]: #time.duration.general
 [time.duration.io]: #time.duration.io
 [time.duration.literals]: #time.duration.literals
 [time.duration.nonmember]: #time.duration.nonmember
 [time.duration.observer]: #time.duration.observer
 [time.duration.special]: #time.duration.special
 [time.point]: #time.point
 [time.point.arithmetic]: #time.point.arithmetic
 [time.point.cast]: #time.point.cast
 [time.point.comparisons]: #time.point.comparisons
 [time.point.cons]: #time.point.cons
+[time.point.general]: #time.point.general
 [time.point.nonmember]: #time.point.nonmember
 [time.point.observer]: #time.point.observer
 [time.point.special]: #time.point.special
 [time.summary]: #time.summary
 [time.syn]: #time.syn

Diff to HTML by rtfpessoa