[time] - C++14 → C++17

Files changed (1) hide show

tmp/tmpax2l32mp/{from.md → to.md} +383 -210

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

@@ -1,47 +1,50 @@
 ## Time utilities <a id="time">[[time]]</a>
 ### In general <a id="time.general">[[time.general]]</a>
 This subclause describes the chrono library ([[time.syn]]) and various
-C functions ([[date.time]]) that provide generally useful time
 utilities.
 ### Header `<chrono>` synopsis <a id="time.syn">[[time.syn]]</a>
 ``` cpp
 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;
-}  // namespace chrono
-// [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> struct duration_values;
     // [time.duration.nonmember], duration arithmetic
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
- constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
- constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Rep2, class Period>
       duration<common_type_t<Rep1, Rep2>, Period>
@@ -49,17 +52,19 @@ template <class Rep1, class Rep2, class Period>
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<Rep1, Rep2>
- constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
- constexpr operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
     // [time.duration.comparisons], duration comparisons
     template <class Rep1, class Period1, class Rep2, class Period2>
       constexpr bool operator==(const duration<Rep1, Period1>& lhs,
                                 const duration<Rep2, Period2>& rhs);
@@ -80,34 +85,44 @@ template <class Rep1, class Period1, class Rep2, class Period2>
                                 const duration<Rep2, Period2>& rhs);
     // [time.duration.cast], duration_cast
     template <class ToDuration, class Rep, class Period>
       constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
     // convenience typedefs
-typedef duration<signed integer type of at least 64 bits, nano> nanoseconds;
-typedef duration<signed integer type of at least 55 bits, micro> microseconds;
-typedef duration<signed integer type of at least 45 bits, milli> milliseconds;
-typedef duration<signed integer type of at least 35 bits > seconds;
-typedef duration<signed integer type of at least 29 bits, ratio<  60>> minutes;
-typedef duration<signed integer type of at least 23 bits, ratio<3600>> hours;
     // [time.point.nonmember], time_point arithmetic
     template <class Clock, class Duration1, class Rep2, class Period2>
       constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
- operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period1, class Clock, class Duration2>
       constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
- operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
     template <class Clock, class Duration1, class Rep2, class Period2>
       constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
- operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
     template <class Clock, class Duration1, class Duration2>
       constexpr common_type_t<Duration1, Duration2>
- operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
-// [time.point.comparisons] time_point comparisons
     template <class Clock, class Duration1, class Duration2>
        constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
                                  const time_point<Clock, Duration2>& rhs);
     template <class Clock, class Duration1, class Duration2>
        constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
@@ -127,22 +142,33 @@ template <class Clock, class Duration1, class Duration2>
     // [time.point.cast], time_point_cast
     template <class ToDuration, class Clock, class Duration>
       constexpr time_point<Clock, ToDuration>
       time_point_cast(const time_point<Clock, Duration>& t);
     // [time.clock], clocks
     class system_clock;
     class steady_clock;
     class high_resolution_clock;
-}  // namespace chrono
   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);
       constexpr chrono::duration<unspecified, ratio<60,1>>   operator""min(long double);
       constexpr chrono::seconds                              operator""s(unsigned long long);
@@ -151,21 +177,17 @@ constexpr chrono::milliseconds                          operator "" ms(unsigned
       constexpr chrono::duration<unspecified, milli>          operator""ms(long double);
       constexpr chrono::microseconds                         operator""us(unsigned long long);
       constexpr chrono::duration<unspecified, micro>         operator""us(long double);
       constexpr chrono::nanoseconds                          operator""ns(unsigned long long);
       constexpr chrono::duration<unspecified, nano>          operator""ns(long double);
-} // namespace chrono_literals
-}  // namespace literals
   namespace chrono {
     using namespace literals::chrono_literals;
-} // namespace chrono
-}  // namespace std
 ```
 ### Clock requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
@@ -174,29 +196,32 @@ clock’s `time_point` is referred to as the clock’s *epoch*. A clock
 shall meet the requirements in Table  [[tab:time.clock]].
 In Table  [[tab:time.clock]] `C1` and `C2` denote clock types. `t1` and
 `t2` are values returned by `C1::now()` where the call returning `t1`
 happens before ([[intro.multithread]]) the call returning `t2` and both
-of these calls occur before `C1::time_point::max()`. this means `C1` did
-not wrap around between `t1` and `t2`.
-The relative difference in durations between those reported by a given
-clock and the SI definition is a measure of the quality of
-implementation.
 A type `TC` meets the `TrivialClock` requirements if:
 - `TC` satisfies the `Clock` requirements ([[time.clock.req]]),
 - the types `TC::rep`, `TC::duration`, and `TC::time_point` satisfy the
-  requirements of `EqualityComparable` (Table [[equalitycomparable]]),
- `LessThanComparable` (Table [[lessthancomparable]]),
- `DefaultConstructible` (Table [[defaultconstructible]]),
- `CopyConstructible` (Table [[copyconstructible]]), `CopyAssignable`
- (Table [[copyassignable]]), `Destructible` (Table [[destructible]]),
   and the requirements of numeric types ([[numeric.requirements]]).
- this means, in particular, that operations on these types will not
-  throw exceptions.
 - 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 `TrivialClock`
   requirements, recursively.
@@ -210,19 +235,21 @@ template <class Rep> struct treat_as_floating_point
   : is_floating_point<Rep> { };
 ```
 The `duration` template uses the `treat_as_floating_point` trait to help
 determine if a `duration` object can be converted to another `duration`
-with a different tick `period`. If `treat_as_floating_point<Rep>::value`
-is true, then implicit conversions are allowed among `duration`s.
 Otherwise, the implicit convertibility depends on the tick `period`s of
-the `duration`s. The intention of this trait is to indicate whether a
-given class behaves like a floating-point type, and thus allows division
-of one value by another with acceptable loss of precision. If
-`treat_as_floating_point<Rep>::value` is `false`, `Rep` will be treated
-as if it behaved like an integral type for the purpose of these
-conversions.
 #### `duration_values` <a id="time.traits.duration_values">[[time.traits.duration_values]]</a>
 ``` cpp
 template <class Rep>
@@ -243,57 +270,62 @@ that case, the author of that class type should specialize
 ``` cpp
 static constexpr Rep zero();
 ```
-*Returns:* `Rep(0)`. `Rep(0)` is specified instead of `Rep()` because
-`Rep()` may have some other meaning, such as an uninitialized value.
-The value returned shall be the additive identity.
 ``` cpp
 static constexpr Rep min();
 ```
 *Returns:* `numeric_limits<Rep>::lowest()`.
-The value returned shall compare less than or equal to `zero()`.
 ``` cpp
 static constexpr Rep max();
 ```
 *Returns:* `numeric_limits<Rep>::max()`.
-The value returned shall compare greater than `zero()`.
 #### Specializations of `common_type` <a id="time.traits.specializations">[[time.traits.specializations]]</a>
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
- typedef chrono::duration<common_type_t<Rep1, Rep2>, see below> type;
 };
 ```
 The `period` of the `duration` indicated by this specialization of
 `common_type` shall be the greatest common divisor of `Period1` and
-`Period2`. This can be computed by forming a ratio of the greatest
 common divisor of `Period1::num` and `Period2::num` and the least common
-multiple of `Period1::den` and `Period2::den`.
-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.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> {
- typedef chrono::time_point<Clock, common_type_t<Duration1, Duration2>> type;
 };
 ```
 The common type of two `time_point` types is a `time_point` with the
 same clock as the two types and the common type of their two
@@ -309,119 +341,129 @@ as a rational constant using the template `ratio`.
 ``` cpp
 template <class Rep, class Period = ratio<1>>
 class duration {
 public:
- typedef Rep    rep;
- typedef Period period;
 private:
   rep rep_;  // exposition only
 public:
-  // [time.duration.cons], construct/copy/destroy:
   constexpr duration() = default;
   template <class Rep2>
       constexpr explicit duration(const Rep2& r);
   template <class Rep2, class Period2>
      constexpr duration(const duration<Rep2, Period2>& d);
   ~duration() = default;
   duration(const duration&) = default;
   duration& operator=(const duration&) = default;
-  // [time.duration.observer], observer:
   constexpr rep count() const;
-  // [time.duration.arithmetic], arithmetic:
-  constexpr duration operator+() const;
-  constexpr duration operator-() const;
-  duration& operator++();
-  duration  operator++(int);
-  duration& operator--();
-  duration  operator--(int);
-  duration& operator+=(const duration& d);
-  duration& operator-=(const duration& d);
-  duration& operator*=(const rep& rhs);
-  duration& operator/=(const rep& rhs);
-  duration& operator%=(const rep& rhs);
-  duration& operator%=(const duration& rhs);
-  // [time.duration.special], special values:
   static constexpr duration zero();
   static constexpr duration min();
   static constexpr duration max();
 };
 ```
-*Requires:* `Rep` shall be an arithmetic type or a class emulating an
-arithmetic type.
-*Remarks:* If `duration` is instantiated with a `duration` type for the
-template argument `Rep`, the program is ill-formed.
-*Remarks:* If `Period` is not a specialization of `ratio`, the program
-is ill-formed.
-*Remarks:* If `Period::num` is not positive, the program is ill-formed.
-*Requires:* Members of `duration` shall not throw exceptions other than
-those thrown by the indicated operations on their representations.
-*Remarks:* 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.
 ``` cpp
 duration<long, ratio<60>> d0;       // holds a count of minutes using a long
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 ```
 #### `duration` constructors <a id="time.duration.cons">[[time.duration.cons]]</a>
 ``` cpp
 template <class Rep2>
   constexpr explicit duration(const Rep2& r);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `rep` and
-- `treat_as_floating_point<rep>::value` is `true` or
-- `treat_as_floating_point<Rep2>::value` is `false`.
 ``` cpp
 duration<int, milli> d(3);          // OK
 duration<int, milli> d(3.5);        // error
 ```
 *Effects:* Constructs an object of type `duration`.
-`count() == static_cast<rep>(r)`.
 ``` cpp
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless no overflow is induced in the conversion and
-`treat_as_floating_point<rep>::value` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
-`treat_as_floating_point<Rep2>::value` is `false`. This requirement
-prevents implicit truncation error when converting between
-integral-based `duration` types. Such a construction could easily lead
-to confusion about the value of the `duration`.
 ``` cpp
 duration<int, milli> ms(3);
 duration<int, micro> us = ms;       // OK
 duration<int, milli> ms2 = us;      // error
 ```
 *Effects:* Constructs an object of type `duration`, constructing `rep_`
 from
 `duration_cast<duration>(d).count()`.
 #### `duration` observer <a id="time.duration.observer">[[time.duration.observer]]</a>
@@ -433,94 +475,94 @@ constexpr rep count() const;
 *Returns:* `rep_`.
 #### `duration` arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
-constexpr duration operator+() const;
 ```
-*Returns:* `*this`.
 ``` cpp
-constexpr duration operator-() const;
 ```
-*Returns:* `duration(-rep_);`.
 ``` cpp
-duration& operator++();
 ```
-*Effects:* `++rep_`.
 *Returns:* `*this`.
 ``` cpp
-duration operator++(int);
 ```
-*Returns:* `duration(rep_++);`.
 ``` cpp
-duration& operator--();
 ```
-*Effects:* `-``-``rep_`.
 *Returns:* `*this`.
 ``` cpp
-duration operator--(int);
 ```
-*Returns:* `duration(rep_--);`.
 ``` cpp
-duration& operator+=(const duration& d);
 ```
-*Effects:* `rep_ += d.count()`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator-=(const duration& d);
 ```
-*Effects:* `rep_ -= d.count()`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator*=(const rep& rhs);
 ```
-*Effects:* `rep_ *= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator/=(const rep& rhs);
 ```
-*Effects:* `rep_ /= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator%=(const rep& rhs);
 ```
-*Effects:* `rep_ %= rhs`.
 *Returns:* `*this`.
 ``` cpp
-duration& operator%=(const duration& rhs);
 ```
-*Effects:* `rep_ %= rhs.count()`.
 *Returns:* `*this`.
 #### `duration` special values <a id="time.duration.special">[[time.duration.special]]</a>
@@ -551,30 +593,30 @@ type of the function. `CR(A,B)` represents `common_type_t<A, B>`.
 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);
 ```
-*Returns:* CD(CD(lhs).count() + CD(rhs).count()).
 ``` cpp
 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);
 ```
-*Returns:* CD(CD(lhs).count() - CD(rhs).count()).
 ``` cpp
 template <class Rep1, class Period, class Rep2>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
-*Returns:* CD(CD(d).count() \* s).
 ``` cpp
 template <class Rep1, class Rep2, class Period>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
@@ -591,13 +633,13 @@ template <class Rep1, class Period, class Rep2>
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
-is not an instantiation of `duration`.
-*Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
@@ -611,66 +653,72 @@ template <class Rep1, class Period, class Rep2>
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
-is not an instantiation of `duration`.
-*Returns:* CD(CD(d).count() % s).
 ``` cpp
 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);
 ```
-*Returns:* CD(CD(lhs).count() % CD(rhs).count()).
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
 `common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs).count() == CT(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs).count() < CT(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `duration_cast` <a id="time.duration.cast">[[time.duration.cast]]</a>
@@ -679,15 +727,15 @@ template <class Rep1, class Period1, class Rep2, class Period2>
 template <class ToDuration, class Rep, class Period>
   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
 ```
 *Remarks:* This function shall not participate in overload resolution
-unless `ToDuration` is an instantiation of `duration`.
 *Returns:* Let `CF` be
 `ratio_divide<Period, typename ToDuration::period>`, and `CR` be
-`common_type<` `typename ToDuration::rep, Rep, intmax_t>::type.`
 - If `CF::num == 1` and `CF::den == 1`, returns
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(d.count()))
   ```
@@ -705,42 +753,81 @@ unless `ToDuration` is an instantiation of `duration`.
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(
     static_cast<CR>(d.count()) * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
   ```
-*Notes:* This function does not use any implicit conversions; all
 conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
-the final step.
 #### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
 This section describes literal suffixes for constructing duration
 literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
 values of the corresponding types `hours`, `minutes`, `seconds`,
 `milliseconds`, `microseconds`, and `nanoseconds` respectively if they
 are applied to integral literals.
-If any of these suffixes are applied to a floating point literal the
-result is a `chrono::duration` literal with an unspecified floating
-point representation.
 If any of these suffixes are applied to an integer literal and the
 resulting `chrono::duration` value cannot be represented in the result
 type because of overflow, the program is ill-formed.
 The following code shows some duration literals.
 ``` cpp
 using namespace std::chrono_literals;
 auto constexpr aday=24h;
 auto constexpr lesson=45min;
 auto constexpr halfanhour=0.5h;
 ```
 ``` cpp
 constexpr chrono::hours                                 operator""h(unsigned long long hours);
 constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double hours);
 ```
@@ -752,19 +839,19 @@ constexpr chrono::duration<unspecified, ratio<60,1>> operator "" min(long double
 ```
 *Returns:* A `duration` literal representing `minutes` minutes.
 ``` cpp
-constexpr chrono::seconds operator "" s(unsigned long long sec);
 constexpr chrono::duration<unspecified> operator""s(long double sec);
 ```
 *Returns:* A `duration` literal representing `sec` seconds.
-The same suffix `s` is used for `basic_string` but there is no conflict,
-since duration suffixes apply to numbers and string literal suffixes
-apply to character array literals.
 ``` cpp
 constexpr chrono::milliseconds                 operator""ms(unsigned long long msec);
 constexpr chrono::duration<unspecified, milli> operator""ms(long double msec);
 ```
@@ -783,44 +870,56 @@ constexpr chrono::nanoseconds                  operator "" ns(unsigned long long
 constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);
 ```
 *Returns:* A `duration` literal representing `nsec` nanoseconds.
 ### Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 template <class Clock, class Duration = typename Clock::duration>
 class time_point {
 public:
- typedef Clock                     clock;
- typedef Duration                  duration;
- typedef typename duration::rep    rep;
- typedef typename duration::period period;
 private:
   duration d_;  // exposition only
 public:
-  // [time.point.cons], construct:
   constexpr time_point();  // has value epoch
   constexpr explicit time_point(const duration& d);  // same as time_point() + d
   template <class Duration2>
     constexpr time_point(const time_point<clock, Duration2>& t);
-  // [time.point.observer], observer:
   constexpr duration time_since_epoch() const;
-  // [time.point.arithmetic], arithmetic:
-  time_point& operator+=(const duration& d);
-  time_point& operator-=(const duration& d);
-  // [time.point.special], special values:
   static constexpr time_point min();
   static constexpr time_point max();
 };
 ```
-`Clock` shall meet the Clock requirements ([[time.clock]]).
 If `Duration` is not an instance of `duration`, the program is
 ill-formed.
 #### `time_point` constructors <a id="time.point.cons">[[time.point.cons]]</a>
@@ -860,22 +959,22 @@ constexpr duration time_since_epoch() const;
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
 ``` cpp
-time_point& operator+=(const duration& d);
 ```
-*Effects:* `d_ += d`.
 *Returns:* `*this`.
 ``` cpp
-time_point& operator-=(const duration& d);
 ```
-*Effects:* `d_ -= d`.
 *Returns:* `*this`.
 #### `time_point` special values <a id="time.point.special">[[time.point.special]]</a>
@@ -897,12 +996,12 @@ static constexpr time_point max();
 template <class Clock, class Duration1, class Rep2, class Period2>
   constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs.time_since_epoch() + rhs)`, where `CT` is the type of
-the return value.
 ``` cpp
 template <class Rep1, class Period1, class Clock, class Duration2>
   constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
@@ -914,11 +1013,12 @@ template <class Rep1, class Period1, class Clock, class Duration2>
 template <class Clock, class Duration1, class Rep2, class Period2>
   constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `lhs + (-rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
   constexpr common_type_t<Duration1, Duration2>
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
@@ -928,46 +1028,52 @@ template <class Clock, class Duration1, class Duration2>
 #### `time_point` comparisons <a id="time.point.comparisons">[[time.point.comparisons]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() == rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() < rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  constexpr bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `time_point_cast` <a id="time.point.cast">[[time.point.cast]]</a>
@@ -977,14 +1083,54 @@ template <class ToDuration, class Clock, class Duration>
   constexpr time_point<Clock, ToDuration>
   time_point_cast(const time_point<Clock, Duration>& t);
 ```
 *Remarks:* This function shall not participate in overload resolution
-unless `ToDuration` is an instantiation of `duration`.
 *Returns:*
-`time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))`.
 ### Clocks <a id="time.clock">[[time.clock]]</a>
 The types defined in this subclause shall satisfy the `TrivialClock`
 requirements ([[time.clock.req]]).
@@ -995,14 +1141,14 @@ Objects of class `system_clock` represent wall clock time from the
 system-wide realtime clock.
 ``` cpp
 class system_clock {
 public:
- typedef see below                           rep;
- typedef ratio<unspecified, unspecified>   period;
- typedef chrono::duration<rep, period>       duration;
- typedef chrono::time_point<system_clock>    time_point;
   static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
   // Map to C API
@@ -1010,33 +1156,35 @@ public:
   static time_point  from_time_t(time_t t) noexcept;
 };
 ```
 ``` cpp
-typedef unspecified system_clock::rep;
 ```
 *Requires:*
 `system_clock::duration::min() < system_clock::duration::zero()` shall
-be `true`. This implies that `rep` is a signed type.
 ``` cpp
 static time_t to_time_t(const time_point& t) noexcept;
 ```
 *Returns:* A `time_t` object that represents the same point in time as
 `t` when both values are restricted to the coarser of the precisions of
-`time_t` and `time_point`. It is implementation defined whether values
 are rounded or truncated to the required precision.
 ``` cpp
 static time_point from_time_t(time_t t) noexcept;
 ```
 *Returns:* A `time_point` object that represents the same point in time
 as `t` when both values are restricted to the coarser of the precisions
-of `time_t` and `time_point`. It is implementation defined whether
 values are rounded or truncated to the required precision.
 #### Class `steady_clock` <a id="time.clock.steady">[[time.clock.steady]]</a>
 Objects of class `steady_clock` represent clocks for which values of
@@ -1045,14 +1193,14 @@ values of `time_point` advance at a steady rate relative to real time.
 That is, the clock may not be adjusted.
 ``` cpp
 class steady_clock {
 public:
- typedef unspecified                               rep;
- typedef ratio<unspecified, unspecified>          period;
- typedef chrono::duration<rep, period>              duration;
- typedef chrono::time_point<unspecified, duration>  time_point;
   static constexpr bool is_steady = true;
   static time_point now() noexcept;
 };
 ```
@@ -1064,26 +1212,51 @@ shortest tick period. `high_resolution_clock` may be a synonym for
 `system_clock` or `steady_clock`.
 ``` cpp
 class high_resolution_clock {
 public:
- typedef unspecified                               rep;
- typedef ratio<unspecified, unspecified>          period;
- typedef chrono::duration<rep, period>              duration;
- typedef chrono::time_point<unspecified, duration> time_point;
   static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
 };
 ```
-### Date and time functions <a id="date.time">[[date.time]]</a>
-Table  [[tab:util.hdr.ctime]] describes the header `<ctime>`.
-The contents are the same as the Standard C library header
-`<time.h>.`[^3] The functions `asctime`, `ctime`, `gmtime`, and
-`localtime` are not required to avoid data races (
-[[res.on.data.races]]).
-ISO C Clause 7.12, Amendment 1 Clause 4.6.4.

 ## Time utilities <a id="time">[[time]]</a>
 ### In general <a id="time.general">[[time.general]]</a>
 This subclause describes the chrono library ([[time.syn]]) and various
+C functions ([[ctime.syn]]) that provide generally useful time
 utilities.
 ### Header `<chrono>` synopsis <a id="time.syn">[[time.syn]]</a>
 ``` cpp
 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> struct duration_values;
+    template <class Rep> inline constexpr bool treat_as_floating_point_v
+      = treat_as_floating_point<Rep>::value;
     // [time.duration.nonmember], duration arithmetic
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
+ constexpr operator+(const duration<Rep1, Period1>& lhs,
+                          const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
+ constexpr operator-(const duration<Rep1, Period1>& lhs,
+                          const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Rep2, class Period>
       duration<common_type_t<Rep1, Rep2>, Period>
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<Rep1, Rep2>
+ constexpr operator/(const duration<Rep1, Period1>& lhs,
+                          const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period, class Rep2>
       duration<common_type_t<Rep1, Rep2>, Period>
       constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
     template <class Rep1, class Period1, class Rep2, class Period2>
       common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
+ constexpr operator%(const duration<Rep1, Period1>& lhs,
+                          const duration<Rep2, Period2>& rhs);
     // [time.duration.comparisons], duration comparisons
     template <class Rep1, class Period1, class Rep2, class Period2>
       constexpr bool operator==(const duration<Rep1, Period1>& lhs,
                                 const duration<Rep2, Period2>& rhs);
                                 const duration<Rep2, Period2>& rhs);
     // [time.duration.cast], duration_cast
     template <class ToDuration, class Rep, class Period>
       constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
+    template <class ToDuration, class Rep, class Period>
+      constexpr ToDuration floor(const duration<Rep, Period>& d);
+    template <class ToDuration, class Rep, class Period>
+      constexpr ToDuration ceil(const duration<Rep, Period>& d);
+    template <class ToDuration, class Rep, class Period>
+      constexpr ToDuration round(const duration<Rep, Period>& d);
     // convenience typedefs
+    using nanoseconds  = duration<signed integer type of at least 64 bits, nano>;
+    using microseconds = duration<signed integer type of at least 55 bits, micro>;
+    using milliseconds = duration<signed integer type of at least 45 bits, milli>;
+    using seconds      = duration<signed integer type of at least 35 bits>;
+    using minutes      = duration<signed integer type of at least 29 bits, ratio<  60>>;
+    using hours        = duration<signed integer type of at least 23 bits, ratio<3600>>;
     // [time.point.nonmember], time_point arithmetic
     template <class Clock, class Duration1, class Rep2, class Period2>
       constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
+ operator+(const time_point<Clock, Duration1>& lhs,
+                const duration<Rep2, Period2>& rhs);
     template <class Rep1, class Period1, class Clock, class Duration2>
       constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
+ operator+(const duration<Rep1, Period1>& lhs,
+                const time_point<Clock, Duration2>& rhs);
     template <class Clock, class Duration1, class Rep2, class Period2>
       constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
+ operator-(const time_point<Clock, Duration1>& lhs,
+                const duration<Rep2, Period2>& rhs);
     template <class Clock, class Duration1, class Duration2>
       constexpr common_type_t<Duration1, Duration2>
+ operator-(const time_point<Clock, Duration1>& lhs,
+                const time_point<Clock, Duration2>& rhs);
+ // [time.point.comparisons], time_point comparisons
     template <class Clock, class Duration1, class Duration2>
        constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
                                  const time_point<Clock, Duration2>& rhs);
     template <class Clock, class Duration1, class Duration2>
        constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
     // [time.point.cast], time_point_cast
     template <class ToDuration, class Clock, class Duration>
       constexpr time_point<Clock, ToDuration>
       time_point_cast(const time_point<Clock, Duration>& t);
+    template <class ToDuration, class Clock, class Duration>
+      constexpr time_point<Clock, ToDuration>
+      floor(const time_point<Clock, Duration>& tp);
+    template <class ToDuration, class Clock, class Duration>
+      constexpr time_point<Clock, ToDuration>
+      ceil(const time_point<Clock, Duration>& tp);
+    template <class ToDuration, class Clock, class Duration>
+      constexpr time_point<Clock, ToDuration>
+      round(const time_point<Clock, Duration>& tp);
+    // [time.duration.alg], specialized algorithms
+    template <class Rep, class Period>
+      constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
     // [time.clock], clocks
     class system_clock;
     class steady_clock;
     class high_resolution_clock;
+  }
   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);
       constexpr chrono::duration<unspecified, ratio<60,1>>   operator""min(long double);
       constexpr chrono::seconds                              operator""s(unsigned long long);
       constexpr chrono::duration<unspecified, milli>          operator""ms(long double);
       constexpr chrono::microseconds                         operator""us(unsigned long long);
       constexpr chrono::duration<unspecified, micro>         operator""us(long double);
       constexpr chrono::nanoseconds                          operator""ns(unsigned long long);
       constexpr chrono::duration<unspecified, nano>          operator""ns(long double);
+    }
+ }
   namespace chrono {
     using namespace literals::chrono_literals;
+  }
+}
 ```
 ### Clock requirements <a id="time.clock.req">[[time.clock.req]]</a>
 A clock is a bundle consisting of a `duration`, a `time_point`, and a
 shall meet the requirements in Table  [[tab:time.clock]].
 In Table  [[tab:time.clock]] `C1` and `C2` denote clock types. `t1` and
 `t2` are values returned by `C1::now()` where the call returning `t1`
 happens before ([[intro.multithread]]) the call returning `t2` and both
+of these calls occur before `C1::time_point::max()`.
+[*Note 1*: This means `C1` did not wrap around between `t1` and
+`t2`. — *end note*]
+[*Note 2*: The relative difference in durations between those reported
+by a given clock and the SI definition is a measure of the quality of
+implementation. — *end note*]
 A type `TC` meets the `TrivialClock` requirements if:
 - `TC` satisfies the `Clock` requirements ([[time.clock.req]]),
 - the types `TC::rep`, `TC::duration`, and `TC::time_point` satisfy the
+  requirements of `EqualityComparable` (Table
+  [[tab:equalitycomparable]]), `LessThanComparable` (Table
+  [[tab:lessthancomparable]]), `DefaultConstructible` (Table
+  [[tab:defaultconstructible]]), `CopyConstructible` (Table
+  [[tab:copyconstructible]]), `CopyAssignable` (Table
+  [[tab:copyassignable]]), `Destructible` (Table  [[tab:destructible]]),
   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 `TrivialClock`
   requirements, recursively.
   : is_floating_point<Rep> { };
 ```
 The `duration` template uses the `treat_as_floating_point` trait to help
 determine if a `duration` object can be converted to another `duration`
+with a different tick `period`. If `treat_as_floating_point_v<Rep>` is
+`true`, then implicit conversions are allowed among `duration`s.
 Otherwise, the implicit convertibility depends on the tick `period`s of
+the `duration`s.
+[*Note 1*: The intention of this trait is to indicate whether a given
+class behaves like a floating-point type, and thus allows division of
+one value by another with acceptable loss of precision. If
+`treat_as_floating_point_v<Rep>` is `false`, `Rep` will be treated as if
+it behaved like an integral type for the purpose of these
+conversions. — *end note*]
 #### `duration_values` <a id="time.traits.duration_values">[[time.traits.duration_values]]</a>
 ``` cpp
 template <class Rep>
 ``` cpp
 static constexpr Rep zero();
 ```
+*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
 static constexpr Rep min();
 ```
 *Returns:* `numeric_limits<Rep>::lowest()`.
+*Remarks:* The value returned shall compare less than or equal to
+`zero()`.
 ``` cpp
 static constexpr Rep max();
 ```
 *Returns:* `numeric_limits<Rep>::max()`.
+*Remarks:* The value returned shall compare greater than `zero()`.
 #### Specializations of `common_type` <a id="time.traits.specializations">[[time.traits.specializations]]</a>
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> {
+ using type = chrono::duration<common_type_t<Rep1, Rep2>, see below>;
 };
 ```
 The `period` of the `duration` indicated by this specialization of
 `common_type` shall be the greatest common divisor of `Period1` and
+`Period2`.
+[*Note 1*: This can be computed by forming a ratio of the greatest
 common divisor of `Period1::num` and `Period2::num` and the least common
+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>>;
 };
 ```
 The common type of two `time_point` types is a `time_point` with the
 same clock as the two types and the common type of their two
 ``` cpp
 template <class Rep, class Period = ratio<1>>
 class duration {
 public:
+ using rep    = Rep;
+ using period = typename Period::type;
 private:
   rep rep_;  // exposition only
 public:
+  // [time.duration.cons], construct/copy/destroy
   constexpr duration() = default;
   template <class Rep2>
       constexpr explicit duration(const Rep2& r);
   template <class Rep2, class Period2>
      constexpr duration(const duration<Rep2, Period2>& d);
   ~duration() = default;
   duration(const duration&) = default;
   duration& operator=(const duration&) = default;
+  // [time.duration.observer], observer
   constexpr rep count() const;
+  // [time.duration.arithmetic], arithmetic
+  constexpr common_type_t<duration> operator+() const;
+  constexpr common_type_t<duration> operator-() const;
+ constexpr duration& operator++();
+ constexpr duration  operator++(int);
+ constexpr duration& operator--();
+ constexpr duration  operator--(int);
+ constexpr duration& operator+=(const duration& d);
+ constexpr duration& operator-=(const duration& d);
+ constexpr duration& operator*=(const rep& rhs);
+ constexpr duration& operator/=(const rep& rhs);
+ constexpr duration& operator%=(const rep& rhs);
+ constexpr duration& operator%=(const duration& rhs);
+  // [time.duration.special], special values
   static constexpr duration zero();
   static constexpr duration min();
   static constexpr duration max();
 };
 ```
+`Rep` shall be an arithmetic type or a class emulating an arithmetic
+type. If `duration` is instantiated with a `duration` type as the
+argument for the template parameter `Rep`, the program is ill-formed.
+If `Period` is not a specialization of `ratio`, the program is
+ill-formed. If `Period::num` is not positive, the program is ill-formed.
+Members of `duration` shall 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
 duration<long long, milli> d1;      // holds a count of milliseconds using a long long
 duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\frac{1}{30}$ of a second
                                     // (30 Hz) using a double
 ```
+— *end example*]
 #### `duration` constructors <a id="time.duration.cons">[[time.duration.cons]]</a>
 ``` cpp
 template <class Rep2>
   constexpr explicit duration(const Rep2& r);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `rep` and
+- `treat_as_floating_point_v<rep>` is `true` or
+- `treat_as_floating_point_v<Rep2>` is `false`.
+[*Example 1*:
 ``` cpp
 duration<int, milli> d(3);          // OK
 duration<int, milli> d(3.5);        // error
 ```
+— *end example*]
 *Effects:* Constructs an object of type `duration`.
+*Postconditions:* `count() == static_cast<rep>(r)`.
 ``` cpp
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless no overflow is induced in the conversion and
+`treat_as_floating_point_v<rep>` is `true` or both
 `ratio_divide<Period2, period>::den` is `1` and
+`treat_as_floating_point_v<Rep2>` is `false`.
+[*Note 1*: This requirement prevents implicit truncation error when
+converting between integral-based `duration` types. Such a construction
+could easily lead to confusion about the value of the
+`duration`. — *end note*]
+[*Example 2*:
 ``` cpp
 duration<int, milli> ms(3);
 duration<int, micro> us = ms;       // OK
 duration<int, milli> ms2 = us;      // error
 ```
+— *end example*]
 *Effects:* Constructs an object of type `duration`, constructing `rep_`
 from
 `duration_cast<duration>(d).count()`.
 #### `duration` observer <a id="time.duration.observer">[[time.duration.observer]]</a>
 *Returns:* `rep_`.
 #### `duration` arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
+constexpr common_type_t<duration> operator+() const;
 ```
+*Returns:* `common_type_t<duration>(*this)`.
 ``` cpp
+constexpr common_type_t<duration> operator-() const;
 ```
+*Returns:* `common_type_t<duration>(-rep_)`.
 ``` cpp
+constexpr duration& operator++();
 ```
+*Effects:* As if by `++rep_`.
 *Returns:* `*this`.
 ``` cpp
+constexpr duration operator++(int);
 ```
+*Returns:* `duration(rep_++)`.
 ``` cpp
+constexpr duration& operator--();
 ```
+*Effects:* As if by `–rep_`.
 *Returns:* `*this`.
 ``` cpp
+constexpr duration operator--(int);
 ```
+*Returns:* `duration(rep_--)`.
 ``` cpp
+constexpr duration& operator+=(const duration& d);
 ```
+*Effects:* As if by: `rep_ += d.count();`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator-=(const duration& d);
 ```
+*Effects:* As if by: `rep_ -= d.count();`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator*=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ *= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator/=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ /= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator%=(const rep& rhs);
 ```
+*Effects:* As if by: `rep_ %= rhs;`
 *Returns:* `*this`.
 ``` cpp
+constexpr duration& operator%=(const duration& rhs);
 ```
+*Effects:* As if by: `rep_ %= rhs.count();`
 *Returns:* `*this`.
 #### `duration` special values <a id="time.duration.special">[[time.duration.special]]</a>
 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);
 ```
+*Returns:* `CD(CD(lhs).count() + CD(rhs).count())`.
 ``` cpp
 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);
 ```
+*Returns:* `CD(CD(lhs).count() - CD(rhs).count())`.
 ``` cpp
 template <class Rep1, class Period, class Rep2>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)`.
+*Returns:* `CD(CD(d).count() * s)`.
 ``` cpp
 template <class Rep1, class Rep2, class Period>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
   operator*(const Rep1& s, const duration<Rep2, Period>& d);
   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
+is not a specialization of `duration`.
+*Returns:* `CD(CD(d).count() / s)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
   constexpr common_type_t<Rep1, Rep2>
   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
   operator%(const duration<Rep1, Period>& d, const Rep2& s);
 ```
 *Remarks:* This operator shall not participate in overload resolution
 unless `Rep2` is implicitly convertible to `CR(Rep1, Rep2)` and `Rep2`
+is not a specialization of `duration`.
+*Returns:* `CD(CD(d).count() % s)`.
 ``` cpp
 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);
 ```
+*Returns:* `CD(CD(lhs).count() % CD(rhs).count())`.
 #### `duration` comparisons <a id="time.duration.comparisons">[[time.duration.comparisons]]</a>
 In the function descriptions that follow, `CT` represents
 `common_type_t<A, B>`, where `A` and `B` are the types of the two
 arguments to the function.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator==(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs).count() == `*`CT`*`(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator<(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs).count() < `*`CT`*`(rhs).count()`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator>(const duration<Rep1, Period1>& lhs,
+                           const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
+  constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
+                            const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `duration_cast` <a id="time.duration.cast">[[time.duration.cast]]</a>
 template <class ToDuration, class Rep, class Period>
   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
 ```
 *Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
 *Returns:* Let `CF` be
 `ratio_divide<Period, typename ToDuration::period>`, and `CR` be
+`common_type<` `typename ToDuration::rep, Rep, intmax_t>::type`.
 - If `CF::num == 1` and `CF::den == 1`, returns
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(d.count()))
   ```
   ``` cpp
   ToDuration(static_cast<typename ToDuration::rep>(
     static_cast<CR>(d.count()) * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
   ```
+[*Note 1*: This function does not use any implicit conversions; all
 conversions are done with `static_cast`. It avoids multiplications and
 divisions when it is known at compile time that one or more arguments
 is 1. Intermediate computations are carried out in the widest
 representation and only converted to the destination representation at
+the final step. — *end note*]
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration floor(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:* The greatest result `t` representable in `ToDuration` for
+which `t <= d`.
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration ceil(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:* The least result `t` representable in `ToDuration` for which
+`t >= d`.
+``` cpp
+template <class ToDuration, class Rep, class Period>
+  constexpr ToDuration round(const duration<Rep, Period>& d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`, and
+`treat_as_floating_point_v<typename ToDuration::rep>` is `false`.
+*Returns:* The value of `ToDuration` that is closest to `d`. If there
+are two closest values, then return the value `t` for which
+`t % 2 == 0`.
 #### Suffixes for duration literals <a id="time.duration.literals">[[time.duration.literals]]</a>
 This section describes literal suffixes for constructing duration
 literals. The suffixes `h`, `min`, `s`, `ms`, `us`, `ns` denote duration
 values of the corresponding types `hours`, `minutes`, `seconds`,
 `milliseconds`, `microseconds`, and `nanoseconds` respectively if they
 are applied to integral literals.
+If any of these suffixes are applied to a floating-point literal the
+result is a `chrono::duration` literal with an unspecified
+floating-point representation.
 If any of these suffixes are applied to an integer literal and the
 resulting `chrono::duration` value cannot be represented in the result
 type because of overflow, the program is ill-formed.
+[*Example 1*:
 The following code shows some duration literals.
 ``` cpp
 using namespace std::chrono_literals;
 auto constexpr aday=24h;
 auto constexpr lesson=45min;
 auto constexpr halfanhour=0.5h;
 ```
+— *end example*]
 ``` cpp
 constexpr chrono::hours                                 operator""h(unsigned long long hours);
 constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double hours);
 ```
 ```
 *Returns:* A `duration` literal representing `minutes` minutes.
 ``` cpp
+constexpr chrono::seconds  \itcorr             operator""s(unsigned long long sec);
 constexpr chrono::duration<unspecified> operator""s(long double sec);
 ```
 *Returns:* A `duration` literal representing `sec` seconds.
+[*Note 1*: The same suffix `s` is used for `basic_string` but there is
+no conflict, since duration suffixes apply to numbers and string literal
+suffixes apply to character array literals. — *end note*]
 ``` cpp
 constexpr chrono::milliseconds                 operator""ms(unsigned long long msec);
 constexpr chrono::duration<unspecified, milli> operator""ms(long double msec);
 ```
 constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);
 ```
 *Returns:* A `duration` literal representing `nsec` nanoseconds.
+#### `duration` algorithms <a id="time.duration.alg">[[time.duration.alg]]</a>
+``` cpp
+template <class Rep, class Period>
+  constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `numeric_limits<Rep>::is_signed` is `true`.
+*Returns:* If `d >= d.zero()`, return `d`, otherwise return `-d`.
 ### Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 template <class Clock, class Duration = typename Clock::duration>
 class time_point {
 public:
+ using clock    = Clock;
+ using duration = Duration;
+ using rep      = typename duration::rep;
+ using period   = typename duration::period;
 private:
   duration d_;  // exposition only
 public:
+  // [time.point.cons], construct
   constexpr time_point();  // has value epoch
   constexpr explicit time_point(const duration& d);  // same as time_point() + d
   template <class Duration2>
     constexpr time_point(const time_point<clock, Duration2>& t);
+  // [time.point.observer], observer
   constexpr duration time_since_epoch() const;
+  // [time.point.arithmetic], arithmetic
+ constexpr time_point& operator+=(const duration& d);
+ constexpr time_point& operator-=(const duration& d);
+  // [time.point.special], special values
   static constexpr time_point min();
   static constexpr time_point max();
 };
 ```
+`Clock` shall meet the Clock requirements ([[time.clock.req]]).
 If `Duration` is not an instance of `duration`, the program is
 ill-formed.
 #### `time_point` constructors <a id="time.point.cons">[[time.point.cons]]</a>
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
 ``` cpp
+constexpr time_point& operator+=(const duration& d);
 ```
+*Effects:* As if by: `d_ += d;`
 *Returns:* `*this`.
 ``` cpp
+constexpr time_point& operator-=(const duration& d);
 ```
+*Effects:* As if by: `d_ -= d;`
 *Returns:* `*this`.
 #### `time_point` special values <a id="time.point.special">[[time.point.special]]</a>
 template <class Clock, class Duration1, class Rep2, class Period2>
   constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs.time_since_epoch() + rhs)`, where *`CT`* is the
+type of the return value.
 ``` cpp
 template <class Rep1, class Period1, class Clock, class Duration2>
   constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Rep2, class Period2>
   constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
+*Returns:* *`CT`*`(lhs.time_since_epoch() - rhs)`, where *`CT`* is the
+type of the return value.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
   constexpr common_type_t<Duration1, Duration2>
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 #### `time_point` comparisons <a id="time.point.comparisons">[[time.point.comparisons]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator==(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() == rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator<(const time_point<Clock, Duration1>& lhs,
+                           const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() < rhs.time_since_epoch()`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator>(const time_point<Clock, Duration1>& lhs,
+                           const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
+  constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
+                            const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 #### `time_point_cast` <a id="time.point.cast">[[time.point.cast]]</a>
   constexpr time_point<Clock, ToDuration>
   time_point_cast(const time_point<Clock, Duration>& t);
 ```
 *Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
 *Returns:*
+``` cpp
+time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))
+```
+``` cpp
+template <class ToDuration, class Clock, class Duration>
+  constexpr time_point<Clock, ToDuration>
+  floor(const time_point<Clock, Duration>& tp);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:*
+`time_point<Clock, ToDuration>(floor<ToDuration>(tp.time_since_epoch()))`.
+``` cpp
+template <class ToDuration, class Clock, class Duration>
+  constexpr time_point<Clock, ToDuration>
+  ceil(const time_point<Clock, Duration>& tp);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`.
+*Returns:*
+`time_point<Clock, ToDuration>(ceil<ToDuration>(tp.time_since_epoch()))`.
+``` cpp
+template <class ToDuration, class Clock, class Duration>
+  constexpr time_point<Clock, ToDuration>
+  round(const time_point<Clock, Duration>& tp);
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `ToDuration` is a specialization of `duration`, and
+`treat_as_floating_point_v<typename ToDuration::rep>` is `false`.
+*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 shall satisfy the `TrivialClock`
 requirements ([[time.clock.req]]).
 system-wide realtime clock.
 ``` cpp
 class system_clock {
 public:
+ using rep        = see below;
+ using period     = ratio<unspecified, unspecified{}>;
+ using duration   = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<system_clock>;
   static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
   // Map to C API
   static time_point  from_time_t(time_t t) noexcept;
 };
 ```
 ``` cpp
+using system_clock::rep = unspecified;
 ```
 *Requires:*
 `system_clock::duration::min() < system_clock::duration::zero()` shall
+be `true`.
+[*Note 1*: This implies that `rep` is a signed type. — *end note*]
 ``` cpp
 static time_t to_time_t(const time_point& t) noexcept;
 ```
 *Returns:* A `time_t` object that represents the same point in time as
 `t` when both values are restricted to the coarser of the precisions of
+`time_t` and `time_point`. It is *implementation-defined* whether values
 are rounded or truncated to the required precision.
 ``` cpp
 static time_point from_time_t(time_t t) noexcept;
 ```
 *Returns:* A `time_point` object that represents the same point in time
 as `t` when both values are restricted to the coarser of the precisions
+of `time_t` and `time_point`. It is *implementation-defined* whether
 values are rounded or truncated to the required precision.
 #### Class `steady_clock` <a id="time.clock.steady">[[time.clock.steady]]</a>
 Objects of class `steady_clock` represent clocks for which values of
 That is, the clock may not be adjusted.
 ``` cpp
 class steady_clock {
 public:
+ using rep        = unspecified;
+ using period     = ratio<unspecified, unspecified{}>;
+ using duration   = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<unspecified, duration>;
   static constexpr bool is_steady = true;
   static time_point now() noexcept;
 };
 ```
 `system_clock` or `steady_clock`.
 ``` cpp
 class high_resolution_clock {
 public:
+ using rep        = unspecified;
+ using period     = ratio<unspecified, unspecified{}>;
+ using duration   = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<unspecified, duration>;
   static constexpr bool is_steady = unspecified;
   static time_point now() noexcept;
 };
 ```
+### Header `<ctime>` synopsis <a id="ctime.syn">[[ctime.syn]]</a>
+``` cpp
+#define NULL see [support.types.nullptr]
+#define CLOCKS_PER_SEC see below
+#define TIME_UTC see below
+namespace std {
+  using size_t = see [support.types.layout];
+  using clock_t = see below;
+  using time_t = see below;
+  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>`. [^3]
+The functions `asctime`, `ctime`, `gmtime`, and `localtime` are not
+required to avoid data races ([[res.on.data.races]]).
+ISO C 7.27.

Diff to HTML by rtfpessoa