[time.duration] - C++17 → C++20

Files changed (1) hide show

tmp/tmpf3bv7qpa/{from.md → to.md} +158 -83

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

@@ -1,21 +1,24 @@
-### 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`.
 ``` 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);
@@ -43,25 +46,26 @@ public:
     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.
@@ -75,19 +79,18 @@ duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of $\fra
                                     // (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*:
@@ -97,21 +100,18 @@ 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
@@ -127,23 +127,21 @@ 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>
 ``` cpp
 constexpr rep count() const;
 ```
 *Returns:* `rep_`.
-#### `duration` arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
 constexpr common_type_t<duration> operator+() const;
 ```
@@ -157,106 +155,106 @@ constexpr common_type_t<duration> operator-() const;
 ``` 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>
 ``` cpp
-static constexpr duration zero();
 ```
 *Returns:* `duration(duration_values<rep>::zero())`.
 ``` cpp
-static constexpr duration min();
 ```
 *Returns:* `duration(duration_values<rep>::min())`.
 ``` cpp
-static constexpr duration max();
 ```
 *Returns:* `duration(duration_values<rep>::max())`.
-#### `duration` non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
-In the function descriptions that follow, `CD` represents the return
-type of the function. `CR(A, B)` represents `common_type_t<A, B>`.
 ``` 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);
@@ -276,55 +274,58 @@ template <class Rep1, class Period1, class Rep2, class Period2>
 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);
 ```
-*Remarks:* This operator shall not participate in overload resolution
-unless `Rep1` is implicitly convertible to `CR(Rep1, Rep2)`.
 *Returns:* `d * s`.
 ``` 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)` 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);
 ```
 *Returns:* `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)` and `Rep2`
-is not a specialization of `duration`.
 *Returns:* `CD(CD(d).count() % s)`.
 ``` cpp
 template<class Rep1, class Period1, class Rep2, class Period2>
@@ -332,11 +333,11 @@ template <class Rep1, class Period1, class Rep2, class 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.
@@ -344,65 +345,65 @@ arguments to the function.
 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>
 ``` cpp
 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()))
   ```
@@ -432,53 +433,50 @@ 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*:
@@ -537,17 +535,94 @@ constexpr chrono::nanoseconds                 operator""ns(unsigned long long ns
 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 `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`.
 ``` cpp
+namespace std::chrono {
   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);
     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() noexcept;
+ static constexpr duration min() noexcept;
+ static constexpr duration max() noexcept;
   };
+}
 ```
 `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` 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.
                                     // (30 Hz) using a double
 ```
 — *end example*]
+### Constructors <a id="time.duration.cons">[[time.duration.cons]]</a>
 ``` cpp
 template<class Rep2>
   constexpr explicit duration(const Rep2& r);
 ```
+*Constraints:* `is_convertible_v<const Rep2&, rep>` is `true` and
 - `treat_as_floating_point_v<rep>` is `true` or
 - `treat_as_floating_point_v<Rep2>` is `false`.
 [*Example 1*:
 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);
 ```
+*Constraints:* 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
 duration<int, milli> ms2 = us;      // error
 ```
 — *end example*]
+*Effects:* Initializes `rep_` with `duration_cast<duration>(d).count()`.
+### Observer <a id="time.duration.observer">[[time.duration.observer]]</a>
 ``` cpp
 constexpr rep count() const;
 ```
 *Returns:* `rep_`.
+### Arithmetic <a id="time.duration.arithmetic">[[time.duration.arithmetic]]</a>
 ``` cpp
 constexpr common_type_t<duration> operator+() const;
 ```
 ``` cpp
 constexpr duration& operator++();
 ```
+*Effects:* Equivalent to: `++rep_`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration operator++(int);
 ```
+*Effects:* Equivalent to: `return duration(rep_++);`
 ``` cpp
 constexpr duration& operator--();
 ```
+*Effects:* Equivalent to: `–rep_`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration operator--(int);
 ```
+*Effects:* Equivalent to: `return duration(rep_--);`
 ``` cpp
 constexpr duration& operator+=(const duration& d);
 ```
+*Effects:* Equivalent to: `rep_ += d.count()`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration& operator-=(const duration& d);
 ```
+*Effects:* Equivalent to: `rep_ -= d.count()`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration& operator*=(const rep& rhs);
 ```
+*Effects:* Equivalent to: `rep_ *= rhs`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration& operator/=(const rep& rhs);
 ```
+*Effects:* Equivalent to: `rep_ /= rhs`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration& operator%=(const rep& rhs);
 ```
+*Effects:* Equivalent to: `rep_ %= rhs`.
 *Returns:* `*this`.
 ``` cpp
 constexpr duration& operator%=(const duration& rhs);
 ```
+*Effects:* Equivalent to: `rep_ %= rhs.count()`.
 *Returns:* `*this`.
+### Special values <a id="time.duration.special">[[time.duration.special]]</a>
 ``` cpp
+static constexpr duration zero() noexcept;
 ```
 *Returns:* `duration(duration_values<rep>::zero())`.
 ``` cpp
+static constexpr duration min() noexcept;
 ```
 *Returns:* `duration(duration_values<rep>::min())`.
 ``` cpp
+static constexpr duration max() noexcept;
 ```
 *Returns:* `duration(duration_values<rep>::max())`.
+### Non-member arithmetic <a id="time.duration.nonmember">[[time.duration.nonmember]]</a>
+In the function descriptions that follow, unless stated otherwise, let
+`CD` represent the return type of the function.
 ``` 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);
 template<class Rep1, class Period, class Rep2>
   constexpr duration<common_type_t<Rep1, Rep2>, Period>
     operator*(const duration<Rep1, Period>& d, const Rep2& s);
 ```
+*Constraints:*
+`is_convertible_v<const Rep2&, common_type_t<Rep1, Rep2>>` is `true`.
 *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);
 ```
+*Constraints:*
+`is_convertible_v<const Rep1&, common_type_t<Rep1, Rep2>>` is `true`.
 *Returns:* `d * s`.
 ``` 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);
 ```
+*Constraints:*
+`is_convertible_v<const Rep2&, common_type_t<Rep1, Rep2>>` is `true` 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);
 ```
+Let `CD` be
+`common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>`.
 *Returns:* `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);
 ```
+*Constraints:*
+`is_convertible_v<const Rep2&, common_type_t<Rep1, Rep2>>` is `true` and
+`Rep2` is not a specialization of `duration`.
 *Returns:* `CD(CD(d).count() % s)`.
 ``` cpp
 template<class Rep1, class Period1, class Rep2, class Period2>
     operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `CD(CD(lhs).count() % CD(rhs).count())`.
+### 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.
 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:* `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)`.
+``` cpp
+template<class Rep1, class Period1, class Rep2, class Period2>
+    requires three_way_comparable<typename CT::rep>
+  constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
+                             const duration<Rep2, Period2>& rhs);
+```
+*Returns:* `CT(lhs).count() <=> CT(rhs).count()`.
+### Conversions <a id="time.duration.cast">[[time.duration.cast]]</a>
 ``` cpp
 template<class ToDuration, class Rep, class Period>
   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
 ```
+*Constraints:* `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
 template<class ToDuration, class Rep, class Period>
   constexpr ToDuration floor(const duration<Rep, Period>& d);
 ```
+*Constraints:* `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);
 ```
+*Constraints:* `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);
 ```
+*Constraints:* `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 subclause 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 *integer-literal*s.
+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*:
 constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);
 ```
 *Returns:* A `duration` literal representing `nsec` nanoseconds.
+### 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);
 ```
+*Constraints:* `numeric_limits<Rep>::is_signed` is `true`.
 *Returns:* If `d >= d.zero()`, return `d`, otherwise return `-d`.
+### I/O <a id="time.duration.io">[[time.duration.io]]</a>
+``` cpp
+template<class charT, class traits, class Rep, class Period>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const duration<Rep, Period>& d);
+```
+*Effects:* Inserts the duration `d` onto the stream `os` as if it were
+implemented as follows:
+``` cpp
+basic_ostringstream<charT, traits> s;
+s.flags(os.flags());
+s.imbue(os.getloc());
+s.precision(os.precision());
+s << d.count() << units-suffix;
+return os << s.str();
+```
+where *`units-suffix`* depends on the type `Period::type` as follows:
+- If `Period::type` is `atto`, *`units-suffix`* is `"as"`.
+- Otherwise, if `Period::type` is `femto`, *`units-suffix`* is `"fs"`.
+- Otherwise, if `Period::type` is `pico`, *`units-suffix`* is `"ps"`.
+- Otherwise, if `Period::type` is `nano`, *`units-suffix`* is `"ns"`.
+- Otherwise, if `Period::type` is `micro`, it is
+  *implementation-defined* whether *`units-suffix`* is `"`\textmu`s"`
+  (`"\u00b5\u0073"`) or `"us"`.
+- Otherwise, if `Period::type` is `milli`, *`units-suffix`* is `"ms"`.
+- Otherwise, if `Period::type` is `centi`, *`units-suffix`* is `"cs"`.
+- Otherwise, if `Period::type` is `deci`, *`units-suffix`* is `"ds"`.
+- Otherwise, if `Period::type` is `ratio<1>`, *`units-suffix`* is `"s"`.
+- Otherwise, if `Period::type` is `deca`, *`units-suffix`* is `"das"`.
+- Otherwise, if `Period::type` is `hecto`, *`units-suffix`* is `"hs"`.
+- Otherwise, if `Period::type` is `kilo`, *`units-suffix`* is `"ks"`.
+- Otherwise, if `Period::type` is `mega`, *`units-suffix`* is `"Ms"`.
+- Otherwise, if `Period::type` is `giga`, *`units-suffix`* is `"Gs"`.
+- Otherwise, if `Period::type` is `tera`, *`units-suffix`* is `"Ts"`.
+- Otherwise, if `Period::type` is `peta`, *`units-suffix`* is `"Ps"`.
+- Otherwise, if `Period::type` is `exa`, *`units-suffix`* is `"Es"`.
+- Otherwise, if `Period::type` is `ratio<60>`, *`units-suffix`* is
+  `"min"`.
+- Otherwise, if `Period::type` is `ratio<3600>`, *`units-suffix`* is
+  `"h"`.
+- Otherwise, if `Period::type` is `ratio<86400>`, *`units-suffix`* is
+  `"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`.
+``` cpp
+template<class charT, class traits, class Rep, class Period, class Alloc = allocator<charT>>
+  basic_istream<charT, traits>&
+    from_stream(basic_istream<charT, traits>& is, const charT* fmt,
+                duration<Rep, Period>& d,
+                basic_string<charT, traits, Alloc>* abbrev = nullptr,
+                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`.

Diff to HTML by rtfpessoa