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

Files changed (1) hide show

tmp/tmpqxkcd0_z/{from.md → to.md} +165 -59

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

@@ -33,32 +33,32 @@ namespace chrono {
 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>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Rep2, class Period>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<Rep1, Rep2>::type
   constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
   constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
 template <class Rep1, class Period1, class Rep2, class Period2>
- typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   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,
@@ -91,60 +91,87 @@ 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>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Rep1, class Period1, class Clock, class Duration2>
-  time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 template <class Clock, class Duration1, class Duration2>
- typename common_type<Duration1, Duration2>::type
   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>
-   bool operator==(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator!=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator< (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator<=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator> (const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 template <class Clock, class Duration1, class Duration2>
-   bool operator>=(const time_point<Clock, Duration1>& lhs,
                              const time_point<Clock, Duration2>& rhs);
 // [time.point.cast], time_point_cast
 template <class ToDuration, class Clock, class Duration>
-  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
 }  // 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
-function `now()` to get the current time_point. The origin of the
 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`
@@ -169,12 +196,12 @@ A type `TC` meets the `TrivialClock` requirements if:
   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.
 ### Time-related traits <a id="time.traits">[[time.traits]]</a>
 #### `treat_as_floating_point` <a id="time.traits.is_fp">[[time.traits.is_fp]]</a>
@@ -242,11 +269,11 @@ 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<typename common_type<Rep1, Rep2>::type, see below> type;
 };
 ```
 The `period` of the `duration` indicated by this specialization of
 `common_type` shall be the greatest common divisor of `Period1` and
@@ -262,11 +289,11 @@ 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, typename common_type<Duration1, Duration2>::type> 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
@@ -337,10 +364,15 @@ 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.
 ``` 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
@@ -372,11 +404,12 @@ duration<int, milli> d(3.5);        // error
 template <class Rep2, class Period2>
   constexpr duration(const duration<Rep2, Period2>& d);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
-unless `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`.
@@ -510,53 +543,53 @@ 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<A, B>::type`.
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   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 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
   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<typename common_type<Rep1, Rep2>::type, 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<typename common_type<Rep1, Rep2>::type, 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<typename common_type<Rep1, Rep2>::type, 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`
@@ -564,19 +597,19 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() / s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<Rep1, Rep2>::type
   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<typename common_type<Rep1, Rep2>::type, 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`
@@ -584,20 +617,20 @@ is not an instantiation of `duration`.
 *Returns:* CD(CD(d).count() % s).
 ``` cpp
 template <class Rep1, class Period1, class Rep2, class Period2>
-  constexpr typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
   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<A, B>::type`, 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);
@@ -679,10 +712,81 @@ 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.
 ### Class template `time_point` <a id="time.point">[[time.point]]</a>
 ``` cpp
 template <class Clock, class Duration = typename Clock::duration>
 class time_point {
@@ -694,17 +798,17 @@ public:
 private:
   duration d_;  // exposition only
 public:
   // [time.point.cons], construct:
-  time_point();  // has value epoch
-  explicit time_point(const duration& d);  // same as time_point() + d
   template <class Duration2>
- time_point(const time_point<clock, Duration2>& t);
   // [time.point.observer], observer:
-  duration time_since_epoch() const;
   // [time.point.arithmetic], arithmetic:
   time_point& operator+=(const duration& d);
   time_point& operator-=(const duration& d);
@@ -720,27 +824,27 @@ 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>
 ``` cpp
-time_point();
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `duration::zero()`. Such a `time_point` object represents the
 epoch.
 ``` cpp
-time_point(const duration& d);
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `d`. Such a `time_point` object represents the epoch `+ d`.
 ``` cpp
 template <class Duration2>
-  time_point(const time_point<clock, Duration2>& t);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Duration2` is implicitly convertible to `duration`.
@@ -748,11 +852,11 @@ unless `Duration2` is implicitly convertible to `duration`.
 with `t.time_since_epoch()`.
 #### `time_point` observer <a id="time.point.observer">[[time.point.observer]]</a>
 ``` cpp
-duration time_since_epoch() const;
 ```
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
@@ -789,89 +893,91 @@ static constexpr time_point max();
 #### `time_point` non-member arithmetic <a id="time.point.nonmember">[[time.point.nonmember]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
-*Returns:* `CT(lhs) += rhs`, where `CT` is the type of the return value.
 ``` cpp
 template <class Rep1, class Period1, class Clock, class Duration2>
-  time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `rhs + lhs`.
 ``` cpp
 template <class Clock, class Duration1, class Rep2, class Period2>
-  time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 ```
 *Returns:* `lhs + (-rhs)`.
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
- typename common_type<Duration1, Duration2>::type
   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 ```
 *Returns:* `lhs.time_since_epoch() - rhs.time_since_epoch()`.
 #### `time_point` comparisons <a id="time.point.comparisons">[[time.point.comparisons]]</a>
 ``` cpp
 template <class Clock, class Duration1, class Duration2>
-  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>
-  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>
-  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>
-  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>
-  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>
-  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>
 ``` cpp
 template <class ToDuration, class Clock, class Duration>
-  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`.
@@ -893,11 +999,11 @@ 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 const bool is_steady = unspecified;
   static time_point now() noexcept;
   // Map to C API
   static time_t      to_time_t  (const time_point& t) noexcept;
@@ -943,11 +1049,11 @@ 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 const bool is_steady = true;
   static time_point now() noexcept;
 };
 ```
@@ -962,11 +1068,11 @@ 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 const bool is_steady = unspecified;
   static time_point now() noexcept;
 };
 ```

 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>
   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
 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,
 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,
                              const time_point<Clock, Duration2>& rhs);
 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,
                              const time_point<Clock, Duration2>& rhs);
 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,
                              const time_point<Clock, Duration2>& rhs);
 // [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);
+constexpr chrono::duration<unspecified>                operator "" s(long double);
+constexpr chrono::milliseconds                          operator "" ms(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_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
+function `now()` to get the current `time_point`. The origin of the
 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`
   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.
 ### Time-related traits <a id="time.traits">[[time.traits]]</a>
 #### `treat_as_floating_point` <a id="time.traits.is_fp">[[time.traits.is_fp]]</a>
 #### 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
 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
 *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
 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`.
 *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);
 ```
 *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);
 ```
 *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`
 *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`
 *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);
 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);
+```
+*Returns:* A `duration` literal representing `hours` hours.
+``` cpp
+constexpr chrono::minutes                             operator "" min(unsigned long long minutes);
+constexpr chrono::duration<unspecified, ratio<60,1>> operator "" min(long double minutes);
+```
+*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);
+```
+*Returns:* A `duration` literal representing `msec` milliseconds.
+``` cpp
+constexpr chrono::microseconds                  operator "" us(unsigned long long usec);
+constexpr chrono::duration<unspecified, micro> operator "" us(long double usec);
+```
+*Returns:* A `duration` literal representing `usec` microseconds.
+``` cpp
+constexpr chrono::nanoseconds                  operator "" ns(unsigned long long nsec);
+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 {
 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);
 ill-formed.
 #### `time_point` constructors <a id="time.point.cons">[[time.point.cons]]</a>
 ``` cpp
+constexpr time_point();
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `duration::zero()`. Such a `time_point` object represents the
 epoch.
 ``` cpp
+constexpr explicit time_point(const duration& d);
 ```
 *Effects:* Constructs an object of type `time_point`, initializing `d_`
 with `d`. Such a `time_point` object represents the epoch `+ d`.
 ``` cpp
 template <class Duration2>
+ constexpr time_point(const time_point<clock, Duration2>& t);
 ```
 *Remarks:* This constructor shall not participate in overload resolution
 unless `Duration2` is implicitly convertible to `duration`.
 with `t.time_since_epoch()`.
 #### `time_point` observer <a id="time.point.observer">[[time.point.observer]]</a>
 ``` cpp
+constexpr duration time_since_epoch() const;
 ```
 *Returns:* `d_`.
 #### `time_point` arithmetic <a id="time.point.arithmetic">[[time.point.arithmetic]]</a>
 #### `time_point` non-member arithmetic <a id="time.point.nonmember">[[time.point.nonmember]]</a>
 ``` cpp
 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);
 ```
 *Returns:* `rhs + lhs`.
 ``` cpp
 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);
 ```
 *Returns:* `lhs.time_since_epoch() - rhs.time_since_epoch()`.
 #### `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>
 ``` cpp
 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`.
 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
   static time_t      to_time_t  (const time_point& t) noexcept;
 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;
 };
 ```
 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;
 };
 ```

Diff to HTML by rtfpessoa