Make to_stream and from_stream return a stream reference

d0355r3.html

@@ -814,12 +814,12 @@ template <class charT, class traits, class Rep, class Period>
                const duration<Rep, Period>& d);
 
 template <class charT, class traits, class Rep, class Period>
-void
+basic_ostream<charT, traits>&
 to_stream(basic_ostream<charT, traits>& os, const charT* fmt,
           const duration<Rep, Period>& d);
 
 template <class Rep, class Period, class charT, class traits, class Alloc = allocator<charT>>
-void
+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,
@@ -967,63 +967,63 @@ template <class charT, class traits, class Duration>
 
 // to_stream
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const sys_time<Duration>& tp);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const local_time<Duration>& tp,
               const string* abbrev = nullptr, const seconds* offset_sec = nullptr);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const utc_time<Duration>& tp);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const tai_time<Duration>& tp);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const gps_time<Duration>& tp);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const file_time<Duration>& tp);
 
 // from_stream
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 sys_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 local_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 utc_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 tai_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 gps_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 file_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1051,11 +1051,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const day& d);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const day& d);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 day& d, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1079,11 +1079,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const month& m);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month& m);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1107,11 +1107,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const year& y);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year& y);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 year& y, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1131,11 +1131,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const weekday& wd);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const weekday& wd);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 weekday& wd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1172,11 +1172,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const month_day& md);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const month_day& md);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 month_day& md, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1234,11 +1234,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const year_month& ym);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month& ym);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 year_month& ym, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1264,11 +1264,11 @@ template<class charT, class traits>
     operator<<(basic_ostream<class charT, class traits>& os, const year_month_day& ymd);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const year_month_day& ymd);
 
 template <class Duration, class charT, class traits, class Alloc = allocator<charT>>
-    void
+    basic_istream<charT, traits>&
     from_stream(basic_istream<charT, traits>& is, const charT* fmt,
                 year_month_day& ymd, basic_string<charT, traits, Alloc>* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -1449,7 +1449,7 @@ template <class Duration>
     operator<<(basic_ostream<class charT, class traits>& os, const zoned_time<Duration>& t);
 
 template <class charT, class traits, class Duration>
-    void
+    basic_ostream<charT, traits>&
     to_stream(basic_ostream<charT, traits>& os, const charT* fmt, const zoned_time<Duration>& tp);
 
 // format
@@ -1673,7 +1673,7 @@ is encouraged.  The implementation may substitute other encodings, including
 
 <pre>
 template &lt;class charT, class traits, class Rep, class Period&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt,
           const duration&lt;Rep, Period&gt;&amp; d);
 </pre>
@@ -1684,11 +1684,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt,
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Rep, class Period, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             duration&lt;Rep, Period&gt;&amp; d,
             basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
@@ -1712,6 +1715,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2033,7 +2039,7 @@ os &lt;&lt; year_month_day{dp};
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const sys_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -2045,11 +2051,14 @@ specified by [time.format].  If <code>%Z</code> is used, it will be replaced wit
 <code>"UTC"</code>.  If <code>%z</code> is used (or a modified form of <code>%z</code>),
 an offset of <code>0min</code> will be formatted.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             sys_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2073,6 +2082,9 @@ will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 Additionally, the parsed offset will be subtracted from the successfully parsed time stamp
 prior to assigning that difference to <code>tp</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2228,7 +2240,7 @@ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const utc_time&lt;D
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const utc_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -2274,7 +2286,7 @@ Output:
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             utc_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2298,6 +2310,9 @@ will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 Additionally, the parsed offset will be subtracted from the successfully parsed time stamp
 prior to assigning that difference to <code>tp</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2418,7 +2433,7 @@ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const tai_time&lt;D
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const tai_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -2458,7 +2473,7 @@ Output:
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             tai_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2482,6 +2497,9 @@ will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 Additionally, the parsed offset will be subtracted from the successfully parsed time stamp
 prior to assigning that difference to <code>tp</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2603,7 +2621,7 @@ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const gps_time&lt;D
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const gps_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -2643,7 +2661,7 @@ Output:
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             gps_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2667,6 +2685,9 @@ will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 Additionally, the parsed offset will be subtracted from the successfully parsed time stamp
 prior to assigning that difference to <code>tp</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2766,7 +2787,7 @@ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const file_time&lt;
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const file_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -2786,7 +2807,7 @@ equivalent to that formatted by a <code>sys_time</code> initialized with <code>t
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             file_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2810,6 +2831,9 @@ will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 Additionally, the parsed offset will be subtracted from the successfully parsed time stamp
 prior to assigning that difference to <code>tp</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2854,7 +2878,7 @@ os &lt;&lt; sys_time&lt;Duration&gt;{lt.time_since_epoch()};
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const local_time&lt;Duration&gt;&amp; tp,
           const string* abbrev = nullptr, const seconds* offset_sec = nullptr);
 </pre>
@@ -2872,11 +2896,14 @@ specified by [time.format].  If <code>%Z</code> is used, it will be replaced wit
 (or a modified form of <code>%z</code>) is used, and <code>offset_sec</code> is equal to
 <code>nullptr</code>, then <code>failbit</code> is set.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             local_time&lt;Duration&gt;&amp; tp, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -2898,6 +2925,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null. 
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -3743,11 +3773,11 @@ basic_ostream&lt;charT, traits&gt;&amp;
 operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const day&amp; d);
 
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const day&amp; d);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             day&amp; d, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -3987,7 +4017,7 @@ operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const day&amp; d);
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const day&amp; d);
 </pre>
 
@@ -3997,11 +4027,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const da
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             day&amp; d, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -4023,6 +4056,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <pre>
@@ -4087,11 +4123,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const month&amp; m);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const month&amp; m);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 month&amp; m, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -4358,7 +4394,7 @@ output for the month field by <code>asctime</code>.  Otherwise outputs
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const month&amp; m);
 </pre>
 
@@ -4368,11 +4404,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const mo
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             month&amp; m, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -4394,6 +4433,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="time.calendar.year"></a><h3>23.17.10.4 Class <code>year</code> [time.calendar.year]</h3>
@@ -4454,11 +4496,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const year&amp; y);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year&amp; y);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 year&amp; y, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -4750,7 +4792,7 @@ into <code>os</code>. If the year is in the range [-999, 999], prefixes the year
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year&amp; y);
 </pre>
 
@@ -4760,11 +4802,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const ye
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             year&amp; y, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -4786,6 +4831,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <pre>
@@ -4867,11 +4915,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const weekday&amp; wd);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const weekday&amp; wd);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 weekday&amp; wd, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -5150,7 +5198,7 @@ output for the weekday field by <code>asctime</code>.  Otherwise outputs
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const weekday&amp; wd);
 </pre>
 
@@ -5160,11 +5208,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const we
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             weekday&amp; wd, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -5186,6 +5237,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="time.calendar.weekday_indexed"></a><h3>23.17.10.6 Class <code>weekday_indexed</code> [time.calendar.weekday_indexed]</h3>
@@ -5460,11 +5514,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const month_day&amp; md);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const month_day&amp; md);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 month_day&amp; md, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -5598,7 +5652,7 @@ return os &lt;&lt; md.month() &lt;&lt; '/' &lt;&lt; md.day();
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const month_day&amp; md);
 </pre>
 
@@ -5608,11 +5662,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const mo
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             month_day&amp; md, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -5634,6 +5691,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="time.calendar.month_day_last"></a><h3>23.17.10.9 Class <code>month_day_last</code> [time.calendar.month_day_last]</h3>
@@ -6066,11 +6126,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const year_month&amp; ym);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year_month&amp; ym);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 year_month&amp; ym, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -6328,7 +6388,7 @@ return os &lt;&lt; ym.year() &lt;&lt; '/' &lt;&lt; ym.month();
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year_month&amp; ym);
 </pre>
 
@@ -6338,11 +6398,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const ye
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             year_month&amp; ym, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -6364,6 +6427,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="time.calendar.year_month_day"></a><h3>23.17.10.13 Class <code>year_month_day</code> [time.calendar.year_month_day]</h3>
@@ -6426,11 +6492,11 @@ template &lt;class charT, class traits&gt;
     operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const year_month_day&amp; ymd);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year_month_day&amp; ymd);
 
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-    void
+    basic_istream&lt;charT, traits&gt;&amp;
     from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
                 year_month_day&amp; ymd, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
                 minutes* offset = nullptr);
@@ -6786,7 +6852,7 @@ are prefixed with <code>'0'</code> if necessary.
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const year_month_day&amp; ymd);
 </pre>
 
@@ -6796,11 +6862,14 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const ye
 the null-terminated array <code>fmt</code>.  <code>fmt</code> encoding follows the rules
 specified by [time.format].
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class charT, class traits, class Alloc = allocator&lt;charT&gt;&gt;
-void
+basic_istream&lt;charT, traits&gt;&amp;
 from_stream(basic_istream&lt;charT, traits&gt;&amp; is, const charT* fmt,
             year_month_day&amp; ymd, basic_string&lt;charT, traits, Alloc&gt;* abbrev = nullptr,
             minutes* offset = nullptr);
@@ -6822,6 +6891,9 @@ If <code>%Z</code> is used and successfully parsed, that value will be assigned
 If <code>%z</code> (or a modified variant) is used and successfully parsed, that value
 will be assigned to <code>*offset</code> if <code>offset</code> is non-null.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="time.calendar.year_month_day_last"></a><h3>23.17.10.14 Class <code>year_month_day_last</code> [time.calendar.year_month_day_last]</h3>
@@ -9537,7 +9609,7 @@ template &lt;class Duration&gt;
     operator&lt;&lt;(basic_ostream&lt;class charT, class traits&gt;&amp; os, const zoned_time&lt;Duration&gt;& t);
 
 template &lt;class charT, class traits, class Duration&gt;
-    void
+    basic_ostream&lt;charT, traits&gt;&amp;
     to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const zoned_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -9860,7 +9932,7 @@ and the value returned from <code>t.get_local_time()</code>.
 
 <pre>
 template &lt;class charT, class traits, class Duration&gt;
-void
+basic_ostream&lt;charT, traits&gt;&amp;
 to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const zoned_time&lt;Duration&gt;&amp; tp);
 </pre>
 
@@ -9870,6 +9942,9 @@ to_stream(basic_ostream&lt;charT, traits&gt;&amp; os, const charT* fmt, const zo
 which for exposition purposes will be referred to as <code>info</code>.  Then calls
 <code>to_stream(os, fmt, tp.get_local_time(), &amp;info.abbrev, &amp;info.offset)</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 </blockquote>

date.html

@@ -1679,7 +1679,7 @@ using months = std::chrono::duration
 
 <pre>
 template &lt;class CharT, class Traits, class Rep, class Period&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const std::chrono::duration&lt;Rep, Period&gt;&amp; d);
 </pre>
@@ -1695,11 +1695,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%R</code>, <code>%S</code>, <code>%T</code>, <code>%X</code>, <code>%n</code>,
 <code>%t</code> or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Rep, class Period, class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             std::chrono::duration&lt;Rep, Period&gt;&amp; d,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
@@ -1720,6 +1723,9 @@ flags): <code>%H</code>, <code>%I</code>, <code>%M</code>, <code>%p</code>,
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <pre>
@@ -1835,7 +1841,7 @@ using sys_seconds = sys_time&lt;std::chrono::seconds&gt;;
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const sys_time&lt;Duration&gt;&amp; tp);
 </pre>
@@ -1849,11 +1855,14 @@ string <code>fmt</code> as specified by the
 <code>%Z</code> is in the formatting string <code>"UTC"</code> will be used.  If
 <code>%z</code> is in the formatting string <code>"+0000"</code> will be used.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             sys_time&lt;Duration&gt;&amp; tp, std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -1872,6 +1881,9 @@ If <code>abbrev</code> is not equal to <code>nullptr</code>, the information par
 is parsed, or a time of day which is outside of the conventional bounds, <code>failbit</code>
 will be set and <code>tp</code> will not be altered.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="local_time"></a><h3><code>local_time</code></h3>
@@ -1930,7 +1942,7 @@ using local_seconds = local_time&lt;std::chrono::seconds&gt;;
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const local_time&lt;Duration&gt;&amp; tp, const std::string* abbrev = nullptr,
           const std::chrono::seconds* offset_sec = nullptr);
@@ -1951,11 +1963,15 @@ If <code>%Z</code> is in the formatting string and <code>abbrev == nullptr</code
 <code>%z</code> is in the formatting string and <code>offset_sec == nullptr</code>,
 <code>failbit</code> will be set for <code>os</code>.
 </p>
+
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             local_time&lt;Duration&gt;&amp; tp, std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -1973,6 +1989,9 @@ If <code>abbrev</code> is not equal to <code>nullptr</code>, the information par
 is parsed, or a time of day which is outside of the conventional bounds, <code>failbit</code>
 will be set and <code>tp</code> will not be altered.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <a name="last_spec"></a><h3><code>last_spec</code></h3>
@@ -2038,12 +2057,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const day&amp; d);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const day&amp; d);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, day&amp; d,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2313,7 +2332,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const day&amp; d);
 </pre>
@@ -2327,11 +2346,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%d</code>, <code>%e</code>, <code>%n</code>,  <code>%t</code>
 or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, day&amp; d,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2350,6 +2372,9 @@ flags): <code>%e</code>, <code>%e</code>, <code>%n</code>,
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2396,12 +2421,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const month&amp; m);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const month&amp; m);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, month&amp; m,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2699,7 +2724,7 @@ output for the month field by <code>asctime</code>.  Otherwise outputs
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const month&amp; m);
 </pre>
@@ -2713,11 +2738,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%b</code>, <code>%B</code>, <code>%h</code>,  <code>%m</code>,  <code>%n</code>,
 <code>%t</code> or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, month&amp; m,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2736,6 +2764,9 @@ flags): <code>%b</code>, <code>%B</code>, <code>%h</code>,  <code>%m</code>,
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2790,12 +2821,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const year&amp; y);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year&amp; y);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year&amp; y,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -3117,7 +3148,7 @@ into <code>os</code>. If the year is less than four decimal digits, pads the yea
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year&amp; y);
 </pre>
@@ -3131,11 +3162,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%C</code>, <code>%y</code>, <code>%Y</code>,  <code>%n</code>,  <code>%t</code>
 or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year&amp; y,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -3154,6 +3188,9 @@ flags): <code>%C</code>, <code>%y</code>, <code>%Y</code>,  <code>%n</code>,
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -3200,12 +3237,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const weekday&amp; wd);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const weekday&amp; wd);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, weekday&amp; wd,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -3525,7 +3562,7 @@ output for the weekday field by <code>asctime</code>.  Otherwise outputs
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const weekday&amp; wd);
 </pre>
@@ -3539,11 +3576,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%a</code>, <code>%A</code>, <code>%u</code>,  <code>%w</code>,  <code>%n</code>,
 <code>%t</code> or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, weekday&amp; wd,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -3562,6 +3602,9 @@ flags): <code>%a</code>, <code>%A</code>, <code>%u</code>, <code>%w</code>, <cod
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -3856,12 +3899,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const month_day&amp; md);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const month_day&amp; md);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, month_day&amp; md,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -4009,7 +4052,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const month_day&amp; md);
 </pre>
@@ -4023,11 +4066,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%b</code>, <code>%B</code>, <code>%d</code>,  <code>%e</code>,  <code>%h</code>,
 <code>%m</code>, <code>%n</code>,  <code>%t</code> or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, month_day&amp; md,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -4047,6 +4093,9 @@ placed in <code>*abbrev</code>.  If <code>offset</code> is not equal to
 <code>nullptr</code>, the information parsed by <code>%z</code> (if present) will be
 placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -4509,12 +4558,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const year_month&amp; ym);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year_month&amp; ym);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year_month&amp; ym,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -4787,7 +4836,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year_month&amp; ym);
 </pre>
@@ -4801,11 +4850,14 @@ is undefined except for the following flags (or modified versions of these flags
 <code>%b</code>, <code>%B</code>, <code>%C</code>, <code>%h</code>, <code>%m</code>,
 <code>%y</code>, <code>%Y</code>,  <code>%n</code>,  <code>%t</code> or <code>%%</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year_month&amp; ym,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -4825,6 +4877,9 @@ placed in <code>*abbrev</code>.  If <code>offset</code> is not equal to
 <code>nullptr</code>, the information parsed by <code>%z</code> (if present) will be
 placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -4881,12 +4936,12 @@ std::basic_ostream&lt;class CharT, class Traits&gt;&amp;
 operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const year_month_day&amp; ymd);
 
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year_month_day&amp; ymd);
 
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year_month_day&amp; ymd,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -5260,7 +5315,7 @@ are prefixed with <code>'0'</code> if necessary..
 
 <pre>
 template&lt;class CharT, class Traits&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const CharT* fmt,
           const year_month_day&amp; ymd);
 </pre>
@@ -5275,11 +5330,14 @@ to_stream(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, const Cha
 If <code>%z</code> or <code>%Z</code> is used in the <code>fmt</code> string
 <code>failbit</code> will be set for <code>os</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class CharT, class Traits, class Alloc = std::allocator&lt;CharT&gt;&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, year_month_day&amp; ymd,
             std::basic_string&lt;CharT, Traits, Alloc&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -5295,6 +5353,9 @@ from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt, y
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>

tz.html

@@ -1617,7 +1617,7 @@ std::basic_ostream<class CharT, class Traits>&
 operator<<(std::basic_ostream<class CharT, class Traits>& os, const zoned_time<Duration>& t)
 
 template <class CharT, class Traits, class Duration>
-void
+std::basic_ostream<CharT, Traits>&
 to_stream(std::basic_ostream<CharT, Traits>& os, const CharT* fmt,
           const zoned_time<Duration>& tp);
 </pre>
@@ -1935,7 +1935,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const zoned_time&lt;Duration&gt;&amp; tp);
 </pre>
@@ -1946,6 +1946,9 @@ to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
 <code>tp.get_info()</code> (stored in a local named <code>info</code> for example).
 Then calls <code>to_stream(os, fmt, tp.get_local_time(), &amp;info.abbrev, &amp;info.offset)</code>.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2205,7 +2208,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const utc_time&lt;Duration&gt;&amp; tp);
 </pre>
@@ -2220,11 +2223,14 @@ Time points representing leap second insertions which format seconds will show
 If <code>%Z</code> is in the formatting string <code>"UTC"</code> will be used.
 If <code>%z</code> is in the formatting string <code>"+0000"</code> will be used.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class CharT, class Traits&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             utc_time&lt;Duration&gt;&amp; tp, std::basic_string&lt;CharT, Traits&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2241,6 +2247,9 @@ If <code>abbrev</code> is not equal to <code>nullptr</code>, the information par
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2355,7 +2364,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const tai_time&lt;Duration&gt;&amp; tp);
 </pre>
@@ -2368,11 +2377,14 @@ string <code>fmt</code> as specified by the
 If <code>%Z</code> is in the formatting string <code>"TAI"</code> will be used.
 If <code>%z</code> is in the formatting string <code>"+0000"</code> will be used.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class CharT, class Traits&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             tai_time&lt;Duration&gt;&amp; tp, std::basic_string&lt;CharT, Traits&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2389,6 +2401,9 @@ If <code>abbrev</code> is not equal to <code>nullptr</code>, the information par
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 </blockquote>
@@ -2502,7 +2517,7 @@ operator&lt;&lt;(std::basic_ostream&lt;class CharT, class Traits&gt;&amp; os, co
 
 <pre>
 template &lt;class CharT, class Traits, class Duration&gt;
-void
+std::basic_ostream&lt;CharT, Traits&gt;&amp;
 to_stream(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, const CharT* fmt,
           const gps_time&lt;Duration&gt;&amp; tp);
 </pre>
@@ -2515,11 +2530,14 @@ string <code>fmt</code> as specified by the
 If <code>%Z</code> is in the formatting string <code>"GPS"</code> will be used.
 If <code>%z</code> is in the formatting string <code>"+0000"</code> will be used.
 </p>
+<p>
+<i>Returns:</i> <code>os</code>.
+</p>
 </blockquote>
 
 <pre>
 template &lt;class Duration, class CharT, class Traits&gt;
-void
+std::basic_istream&lt;CharT, Traits&gt;&amp;
 from_stream(std::basic_istream&lt;CharT, Traits&gt;&amp; is, const CharT* fmt,
             gps_time&lt;Duration&gt;&amp; tp, std::basic_string&lt;CharT, Traits&gt;* abbrev = nullptr,
             std::chrono::minutes* offset = nullptr);
@@ -2536,6 +2554,9 @@ If <code>abbrev</code> is not equal to <code>nullptr</code>, the information par
 <code>offset</code> is not equal to <code>nullptr</code>, the information parsed by
 <code>%z</code> (if present) will be placed in <code>*offset</code>.
 </p>
+<p>
+<i>Returns:</i> <code>is</code>.
+</p>
 </blockquote>
 
 <p>