[iostream.format] - C++17 → C++20

Files changed (1) hide show

tmp/tmpdpy0grum/{from.md → to.md} +288 -207

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

@@ -39,10 +39,17 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits, class T>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 }
 ```
@@ -52,11 +59,11 @@ namespace std {
 namespace std {
   // types T1, T2, ... are unspecified implementation types
   T1 resetiosflags(ios_base::fmtflags mask);
   T2 setiosflags  (ios_base::fmtflags mask);
   T3 setbase(int base);
-  template<charT> T4 setfill(charT c);
   T5 setprecision(int n);
   T6 setw(int n);
   template<class moneyT> T7 get_money(moneyT& mon, bool intl = false);
   template<class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
   template<class charT> T9 get_time(struct tm* tmb, const charT* fmt);
@@ -90,22 +97,22 @@ extracts from stream rvalues.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from basic_ios ([ios])):
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
     using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
-    // [istream::sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
     basic_istream<charT, traits>&
       operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
@@ -155,15 +162,15 @@ namespace std {
     basic_istream<charT, traits>& seekg(pos_type);
     basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
-    basic_istream(const basic_istream& rhs) = delete;
     basic_istream(basic_istream&& rhs);
     // [istream.assign], assign and swap
-    basic_istream& operator=(const basic_istream& rhs) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
   // [istream.extractors], character extraction templates
@@ -172,16 +179,16 @@ namespace std {
   template<class traits>
     basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char&);
   template<class traits>
     basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char&);
-  template<class charT, class traits>
-    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT*);
-  template<class traits>
-    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char*);
-  template<class traits>
-    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char*);
 }
 ```
 The class template `basic_istream` defines a number of member function
 signatures that assist in reading and interpreting input from sequences
@@ -194,72 +201,67 @@ obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
 If `rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`,
 then the input function, except as explicitly noted otherwise, completes
 its actions and does `setstate(eofbit)`, which may throw
-`ios_base::failure` ([[iostate.flags]]), before returning.
 If one of these called functions throws an exception, then unless
-explicitly noted otherwise, the input function sets `badbit` in error
-state. If `badbit` is on in `exceptions()`, the input function rethrows
-the exception without completing its actions, otherwise it does not
-throw anything and proceeds as if the called function had returned a
 failure indication.
-##### `basic_istream` constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_istream`, initializing
-the base class subobject with
-`basic_ios::init(sb)` ([[basic.ios.cons]]).
-*Postconditions:* `gcount() == 0`.
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
-*Effects:* Move constructs from the rvalue `rhs`. This is accomplished
-by default constructing the base class, copying the `gcount()` from
-`rhs`, calling `basic_ios<charT, traits>::move(rhs)` to initialize the
-base class, and setting the `gcount()` for `rhs` to 0.
 ``` cpp
 virtual ~basic_istream();
 ```
-*Effects:* Destroys an object of class `basic_istream`.
 *Remarks:* Does not perform any operations of `rdbuf()`.
-##### Class `basic_istream` assign and swap <a id="istream.assign">[[istream.assign]]</a>
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`. Exchanges the
 values returned by `gcount()` and `rhs.gcount()`.
-##### Class `basic_istream::sentry` <a id="istream::sentry">[[istream::sentry]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
-    using traits_type = traits;
     bool ok_;                   // exposition only
   public:
     explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
@@ -310,11 +312,11 @@ if (ctype.is(ctype.space, c) != 0)
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]))[^19]
 ``` cpp
 ~sentry();
 ```
@@ -322,23 +324,23 @@ constructor may call `setstate(failbit)` (which may throw
 ``` cpp
 explicit operator bool() const;
 ```
-*Effects:* Returns `ok_`.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
 of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
 `bool`, the function endeavors to obtain the requested input. If an
-exception is thrown during input then `ios::badbit` is turned on[^20] in
-`*this`’s error state. If `(exceptions()&badbit) != 0` then the
-exception is rethrown. In any case, the formatted input function
 destroys the `sentry` object. If no exception has been thrown, it
 returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
@@ -355,11 +357,11 @@ operator>>(long double& val);
 operator>>(bool& val);
 operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
-`num_get<>` ([[locale.num.get]]) object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
 described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
 fragment:
@@ -459,26 +461,23 @@ formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-template<class charT, class traits>
-  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT* s);
-template<class traits>
-  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char* s);
-template<class traits>
-  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char* s);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
-constructed, `operator>>` extracts characters and stores them into
-successive locations of an array whose first element is designated by
-`s`. If `width()` is greater than zero, `n` is `width()`. Otherwise `n`
-is the number of elements of the largest array of `char_type` that can
-store a terminating `charT()`. `n` is the maximum number of characters
-stored.
 Characters are extracted and stored until any of the following occurs:
 - `n-1` characters are stored;
 - end of file occurs on the input sequence;
@@ -488,11 +487,11 @@ Characters are extracted and stored until any of the following occurs:
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
 If the function extracted no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` ([[iostate.flags]]).
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
@@ -512,28 +511,28 @@ stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 ``` cpp
 basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Behaves as an unformatted input function
-([[istream.unformatted]]). If `sb` is null, calls `setstate(failbit)`,
-which may throw `ios_base::failure` ([[iostate.flags]]). After a sentry
-object is constructed, extracts characters from `*this` and inserts them
-in the output sequence controlled by `sb`. Characters are extracted and
-inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
 If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` ([[iostate.flags]]). If it inserted
-no characters because it caught an exception thrown while extracting
-characters from `*this` and `failbit` is on in
-`exceptions()` ([[iostate.flags]]), then the caught exception is
-rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
@@ -546,14 +545,14 @@ an exception or if the sentry object returns `false`, when converted to
 a value of type `bool`, the function returns without attempting to
 obtain any input. In either case the number of extracted characters is
 set to 0; unformatted input functions taking a character array of
 nonzero size as an argument shall also store a null character (using
 `charT()`) in the first location of the array. If an exception is thrown
-during input then `ios::badbit` is turned on[^23] in `*this`’s error
-state. (Exceptions thrown from `basic_ios<>::clear()` are not caught or
-rethrown.) If `(exceptions()&badbit) != 0` then the exception is
-rethrown. It also counts the number of characters extracted. If no
 exception has been thrown it ends by storing the count in a member
 object and returning the value specified. In any event the `sentry`
 object is destroyed before leaving the unformatted input function.
 ``` cpp
@@ -571,23 +570,23 @@ int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts a character `c`, if
 one is available. Otherwise, the function calls `setstate(failbit)`,
-which may throw `ios_base::failure` ([[iostate.flags]]),
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts a character, if one
 is available, and assigns it to `c`.[^24] Otherwise, the function calls
-`setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
@@ -604,13 +603,13 @@ the following occurs:
   calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
 If the function stores no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])). In any case,
-if `n` is greater than zero it then stores a null character into the
-next successive location of the array.
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n);
@@ -636,11 +635,11 @@ extracted and inserted until any of the following occurs:
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
 If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` ([[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
@@ -669,11 +668,11 @@ the following occurs:
     the function calls `setstate(failbit)`).
 These conditions are tested in the order shown.[^28]
 If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])).[^29]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
@@ -721,15 +720,15 @@ basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
-- `n != numeric_limits<streamsize>::max()` ([[numeric.limits]]) and `n`
   characters have been extracted so far
 - end-of-file occurs on the input sequence (in which case the function
-  calls `setstate(eofbit)`, which may throw
- `ios_base::failure` ([[iostate.flags]]));
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
 *Remarks:* The last condition will never occur if
 `traits::eq_int_type(delim, traits::eof())`.
@@ -759,11 +758,11 @@ array whose first element is designated by `s`.[^30] Characters are
 extracted and stored until either of the following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
-  `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
@@ -773,11 +772,11 @@ streamsize readsome(char_type* s, streamsize n);
 above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])), and extracts no characters;
 - If `rdbuf()->in_avail() == 0`, extracts no characters
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
@@ -788,13 +787,13 @@ basic_istream<charT, traits>& putback(char_type c);
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
 constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
-calls `rdbuf->sputbackc()`. If `rdbuf()` is null, or if `sputbackc()`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
 [*Note 1*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
@@ -805,13 +804,13 @@ basic_istream<charT, traits>& unget();
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
 constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
-calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc()`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
@@ -824,11 +823,11 @@ int sync();
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`. After constructing a sentry object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]), and returns `-1`. Otherwise,
 returns zero.
 ``` cpp
 pos_type tellg();
 ```
@@ -872,45 +871,49 @@ function calls `setstate(failbit)` (which may throw
 *Returns:* `*this`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
 ```
-*Effects:* Behaves as an unformatted input function
-([[istream.unformatted]]), except that it does not count the number of
-characters extracted and does not affect the value returned by
-subsequent calls to is.gcount(). After constructing a sentry object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
-by `sentry::sentry` ([[istream::sentry]]). If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
 `failbit`.
 *Returns:* `is`.
 #### Rvalue stream extraction <a id="istream.rvalue">[[istream.rvalue]]</a>
 ``` cpp
-template <class charT, class traits, class T>
- basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
 ```
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
-return is;
 ```
-*Remarks:* This function shall not participate in overload resolution
-unless the expression `is >> std::forward<T>(x)` is well-formed.
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
@@ -930,62 +933,59 @@ namespace std {
     // [iostream.dest], destructor
     virtual ~basic_iostream();
   protected:
     // [iostream.cons], constructor
-    basic_iostream(const basic_iostream& rhs) = delete;
     basic_iostream(basic_iostream&& rhs);
     // [iostream.assign], assign and swap
-    basic_iostream& operator=(const basic_iostream& rhs) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ```
 The class template `basic_iostream` inherits a number of functions that
 allow reading input and writing output to sequences controlled by a
 stream buffer.
-##### `basic_iostream` constructors <a id="iostream.cons">[[iostream.cons]]</a>
 ``` cpp
 explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_iostream`, initializing
-the base class subobjects with
-`basic_istream<charT, traits>(sb)` ([[istream]]) and
-`basic_ostream<charT, traits>(sb)` ([[ostream]]).
-*Postconditions:* `rdbuf() == sb` and `gcount() == 0`.
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
 `basic_istream` base class with `move(rhs)`.
-##### `basic_iostream` destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
 ```
-*Effects:* Destroys an object of class `basic_iostream`.
 *Remarks:* Does not perform any operations on `rdbuf()`.
-##### `basic_iostream` assign and swap <a id="iostream.assign">[[iostream.assign]]</a>
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
@@ -1002,22 +1002,22 @@ that inserts into stream rvalues.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from basic_ios ([ios])):
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
     using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
-    // [ostream::sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
@@ -1054,15 +1054,15 @@ namespace std {
     basic_ostream<charT, traits>& seekp(pos_type);
     basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
-    basic_ostream(const basic_ostream& rhs) = delete;
     basic_ostream(basic_ostream&& rhs);
     // [ostream.assign], assign and swap
-    basic_ostream& operator=(const basic_ostream& rhs) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
   // [ostream.inserters.character], character inserters
@@ -1076,10 +1076,28 @@ namespace std {
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, signed char);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, unsigned char);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const charT*);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const char*);
   template<class traits>
@@ -1087,10 +1105,32 @@ namespace std {
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const signed char*);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const unsigned char*);
 }
 ```
 The class template `basic_ostream` defines a number of member function
 signatures that assist in formatting and writing output to output
@@ -1103,26 +1143,29 @@ output functions.* Both groups of output functions generate (or
 `rdbuf()->sputc(int_type)`. They may use other public members of
 `basic_ostream` except that they shall not invoke any virtual members of
 `rdbuf()` except `overflow()`, `xsputn()`, and `sync()`.
 If one of these called functions throws an exception, then unless
-explicitly noted otherwise the output function sets `badbit` in error
-state. If `badbit` is on in `exceptions()`, the output function rethrows
-the exception without completing its actions, otherwise it does not
-throw anything and treat as an error.
-##### `basic_ostream` constructors <a id="ostream.cons">[[ostream.cons]]</a>
 ``` cpp
 explicit basic_ostream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_ostream`, initializing
-the base class subobject with
-`basic_ios<charT, traits>::init(sb)` ([[basic.ios.cons]]).
-*Postconditions:* `rdbuf() == sb`.
 ``` cpp
 basic_ostream(basic_ostream&& rhs);
 ```
@@ -1132,31 +1175,29 @@ by default constructing the base class and calling
 ``` cpp
 virtual ~basic_ostream();
 ```
-*Effects:* Destroys an object of class `basic_ostream`.
 *Remarks:* Does not perform any operations on `rdbuf()`.
-##### Class `basic_ostream` assign and swap <a id="ostream.assign">[[ostream.assign]]</a>
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
-*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`.
-##### Class `basic_ostream::sentry` <a id="ostream::sentry">[[ostream::sentry]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream<charT, traits>::sentry {
@@ -1183,11 +1224,11 @@ If `os.good()` is nonzero, prepares for formatted or unformatted output.
 If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^31]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]))[^32]
 ``` cpp
 ~sentry();
 ```
@@ -1200,11 +1241,11 @@ sets `badbit` in `os.rdstate()` without propagating an exception.
 explicit operator bool() const;
 ```
 *Effects:* Returns `ok_`.
-##### `basic_ostream` seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 ``` cpp
@@ -1243,12 +1284,12 @@ function calls `setstate(failbit)` (which may throw
 Each formatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
 function does `setstate(ios_base::failbit)`, which might throw an
-exception. If an exception is thrown during output, then `ios::badbit`
-is turned on[^33] in `*this`’s error state. If
 `(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
 not an exception is thrown, the `sentry` object is destroyed before
 leaving the formatted output function. If no exception is thrown, the
 result of the formatted output function is `*this`.
@@ -1389,13 +1430,13 @@ in  [[ostream.formatted.reqmts]]).
 ``` cpp
 basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Behaves as an unformatted output function
-([[ostream.unformatted]]). After the sentry object is constructed, if
-`sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
@@ -1403,14 +1444,14 @@ read from `sb` and inserted until any of the following occurs:
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs while getting a character from `sb`.
 If the function inserts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])). If an
-exception was thrown while extracting a character, the function sets
-`failbit` in error state, and if `failbit` is on in `exceptions()` the
-caught exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
 basic_ostream<charT, traits>& operator<<(nullptr_t);
@@ -1420,11 +1461,11 @@ basic_ostream<charT, traits>& operator<<(nullptr_t);
 ``` cpp
 return *this << s;
 ```
-where `s` is an *implementation-defined* NTCTS ([[defns.ntcts]]).
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
@@ -1440,16 +1481,16 @@ template<class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
-function ([[ostream.formatted.reqmts]]) of `out`. Constructs a
-character sequence `seq`. If `c` has type `char` and the character type
-of the stream is not `char`, then `seq` consists of `out.widen(c)`;
-otherwise `seq` consists of `c`. Determines padding for `seq` as
-described in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`.
-Calls `os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
@@ -1463,17 +1504,17 @@ template<class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
-*Requires:* `s` shall not be a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
 in  [[ostream.formatted.reqmts]]) of `out`. Creates a character sequence
 `seq` of `n` characters starting at `s`, each widened using
-`out.widen()` ([[basic.ios.members]]), where `n` is the number that
-would be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
@@ -1494,11 +1535,11 @@ in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
 Each unformatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
-`ios::badbit` is turned on[^36] in `*this`’s error state. If
 `(exceptions() & badbit) != 0` then the exception is rethrown. In any
 case, the unformatted output function ends by destroying the sentry
 object, then, if no exception was thrown, returning the value specified
 for the unformatted output function.
@@ -1508,12 +1549,12 @@ basic_ostream<charT, traits>& put(char_type c);
 *Effects:* Behaves as an unformatted output function (as described
 above). After constructing a sentry object, inserts the character `c`,
 if possible.[^37]
-Otherwise, calls `setstate(badbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
@@ -1525,12 +1566,12 @@ from successive locations of an array whose first element is designated
 by `s`.[^38] Characters are inserted until either of the following
 occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
-  calls `setstate(badbit)`, which may throw
- `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& flush();
@@ -1538,17 +1579,20 @@ basic_ostream& flush();
 *Effects:* Behaves as an unformatted output function (as described
 above). If `rdbuf()` is not a null pointer, constructs a sentry object.
 If this object returns `true` when converted to a value of type `bool`
 the function calls `rdbuf()->pubsync()`. If that function returns -1
-calls `setstate(badbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]])). Otherwise, if the sentry
-object returns `false`, does nothing.
 *Returns:* `*this`.
-#### Standard `basic_ostream` manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
 ```
@@ -1574,23 +1618,64 @@ template <class charT, class traits>
 *Effects:* Calls `os.flush()`.
 *Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
 ``` cpp
-template <class charT, class traits, class T>
- basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 ```
 *Effects:* As if by: `os << x;`
-*Returns:* `os`.
-*Remarks:* This function shall not participate in overload resolution
-unless the expression `os << x` is well-formed.
 ### Standard manipulators <a id="std.manip">[[std.manip]]</a>
 The header `<iomanip>` defines several functions that support extractors
 and inserters that alter information maintained by class `ios_base` and
@@ -1612,14 +1697,14 @@ void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
 }
 ```
-The expression `out << resetiosflags(mask)` shall have type
 `basic_ostream<charT, traits>&` and value `out`. The expression
-`in >> resetiosflags(mask)` shall have type
-`basic_istream<charT, traits>&` and value `in`.
 ``` cpp
 unspecified setiosflags(ios_base::fmtflags mask);
 ```
@@ -1635,14 +1720,14 @@ void f(ios_base& str, ios_base::fmtflags mask) {
   // set specified flags
   str.setf(mask);
 }
 ```
-The expression `out << setiosflags(mask)` shall have type
 `basic_ostream<charT, traits>&` and value `out`. The expression
-`in >> setiosflags(mask)` shall have type `basic_istream<charT,`
-`traits>&` and value `in`.
 ``` cpp
 unspecified setbase(int base);
 ```
@@ -1661,14 +1746,14 @@ void f(ios_base& str, int base) {
       base == 16 ? ios_base::hex :
       ios_base::fmtflags(0), ios_base::basefield);
 }
 ```
-The expression `out << setbase(base)` shall have type
 `basic_ostream<charT, traits>&` and value `out`. The expression
-`in >> setbase(base)` shall have type `basic_istream<charT, traits>&`
-and value `in`.
 ``` cpp
 unspecified setfill(char_type c);
 ```
@@ -1683,11 +1768,11 @@ void f(basic_ios<charT, traits>& str, charT c) {
   // set fill character
   str.fill(c);
 }
 ```
-The expression `out << setfill(c)` shall have type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 unspecified setprecision(int n);
 ```
@@ -1704,14 +1789,14 @@ void f(ios_base& str, int n) {
   // set precision
   str.precision(n);
 }
 ```
-The expression `out << setprecision(n)` shall have type
 `basic_ostream<charT, traits>&` and value `out`. The expression
-`in >> setprecision(n)` shall have type `basic_istream<charT, traits>&`
-and value `in`.
 ``` cpp
 unspecified setw(int n);
 ```
@@ -1727,14 +1812,13 @@ void f(ios_base& str, int n) {
   // set width
   str.width(n);
 }
 ```
-The expression `out << setw(n)` shall have type
-`basic_ostream<charT, traits>&` and value `out`. The expression
-`in >> setw(n)` shall have type `basic_istream<charT, traits>&` and
-value `in`.
 ### Extended manipulators <a id="ext.manip">[[ext.manip]]</a>
 The header `<iomanip>` defines several functions that support extractors
 and inserters that allow for the parsing and formatting of sequences and
@@ -1742,15 +1826,15 @@ values for money and time.
 ``` cpp
 template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
 ```
-*Requires:* The type `moneyT` shall be either `long double` or a
-specialization of the `basic_string` template (Clause  [[strings]]).
 *Effects:* The expression `in >> get_money(mon, intl)` described below
-behaves as a formatted input function ([[istream.formatted.reqmts]]).
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_money(mon, intl)` behaves as if it called `f(in, mon, intl)`,
 where the function `f` is defined as:
@@ -1769,24 +1853,24 @@ void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
   if (ios_base::goodbit != err)
     str.setstate(err);
 }
 ```
-The expression `in >> get_money(mon, intl)` shall have type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
 template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
 ```
-*Requires:* The type `moneyT` shall be either `long double` or a
-specialization of the `basic_string` template (Clause  [[strings]]).
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_money(mon, intl)` behaves as a formatted output
-function ([[ostream.formatted.reqmts]]) that calls `f(out, mon, intl)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
@@ -1795,25 +1879,24 @@ void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
   const MoneyPut& mp = use_facet<MoneyPut>(str.getloc());
   const Iter end = mp.put(Iter(str.rdbuf()), intl, str, str.fill(), mon);
   if (end.failed())
-    str.setstate(ios::badbit);
 }
 ```
-The expression `out << put_money(mon, intl)` shall have type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 template<class charT> unspecified get_time(struct tm* tmb, const charT* fmt);
 ```
-*Requires:* The argument `tmb` shall be a valid pointer to an object of
-type `struct tm`. The argument `fmt` shall be a valid pointer to an
-array of objects of type `charT` with `char_traits<charT>::length(fmt)`
-elements.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
@@ -1833,21 +1916,20 @@ void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
   if (err != ios_base::goodbit)
     str.setstate(err);
 }
 ```
-The expression `in >> get_time(tmb, fmt)` shall have type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
 template<class charT> unspecified put_time(const struct tm* tmb, const charT* fmt);
 ```
-*Requires:* The argument `tmb` shall be a valid pointer to an object of
-type `struct tm`, and the argument `fmt` shall be a valid pointer to an
-array of objects of type `charT` with `char_traits<charT>::length(fmt)`
-elements.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
@@ -1865,11 +1947,11 @@ void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
   if (end.failed())
     str.setstate(ios_base::badbit);
 }
 ```
-The expression `out << put_time(tmb, fmt)` shall have type
 `basic_ostream<charT, traits>&` and value `out`.
 ### Quoted manipulators <a id="quoted.manip">[[quoted.manip]]</a>
 [*Note 1*: Quoted manipulators provide string insertion and extraction
@@ -1892,13 +1974,12 @@ template <class charT, class traits>
 *Returns:* An object of unspecified type such that if `out` is an
 instance of `basic_ostream` with member type `char_type` the same as
 `charT` and with member type `traits_type`, which in the second and
 third forms is the same as `traits`, then the expression
 `out << quoted(s, delim, escape)` behaves as a formatted output
-function ([[ostream.formatted.reqmts]]) of `out`. This forms a
-character sequence `seq`, initially consisting of the following
-elements:
 - `delim`.
 - Each character in `s`. If the character to be output is equal to
   `escape` or `delim`, as determined by `traits_type::eq`, first output
   `escape`.
@@ -1906,11 +1987,11 @@ elements:
 Let `x` be the number of elements initially in `seq`. Then padding is
 determined for `seq` as described in  [[ostream.formatted.reqmts]],
 `seq` is inserted as if by calling `out.rdbuf()->sputn(seq, n)`, where
 `n` is the larger of `out.width()` and `x`, and `out.width(0)` is
-called. The expression `out << quoted(s, delim, escape)` shall have type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   unspecified quoted(basic_string<charT, traits, Allocator>& s,
@@ -1921,12 +2002,13 @@ template <class charT, class traits, class Allocator>
 - If `in` is an instance of `basic_istream` with member types
   `char_type` and `traits_type` the same as `charT` and `traits`,
   respectively, then the expression `in >> quoted(s, delim, escape)`
   behaves as if it extracts the following characters from `in` using
-  `operator>>(basic_istream<charT, traits>&, charT&)` ([[istream.extractors]])
-  which may throw `ios_base::failure` ([[ios::failure]]):
   - If the first character extracted is equal to `delim`, as determined
     by `traits_type::eq`, then:
     - Turn off the `skipws` flag.
     - `s.clear()`
     - Until an unescaped `delim` character is reached or `!in`, extract
@@ -1940,11 +2022,10 @@ template <class charT, class traits, class Allocator>
   `char_type` and `traits_type` the same as `charT` and `traits`,
   respectively, then the expression `out << quoted(s, delim, escape)`
   behaves as specified for the
   `const basic_string<charT, traits, Allocator>&` overload of the
   `quoted` function.
-The expression `in >> quoted(s, delim, escape)` shall have type
-`basic_istream<charT, traits>&` and value `in`. The expression
-`out << quoted(s, delim, escape)` shall have type
   `basic_ostream<charT, traits>&` and value `out`.

   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);
+  template<class charT, class traits>
+    basic_ostream<charT, traits>& emit_on_flush(basic_ostream<charT, traits>& os);
+  template<class charT, class traits>
+    basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
+  template<class charT, class traits>
+    basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
   template<class charT, class traits, class T>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&& os, const T& x);
 }
 ```
 namespace std {
   // types T1, T2, ... are unspecified implementation types
   T1 resetiosflags(ios_base::fmtflags mask);
   T2 setiosflags  (ios_base::fmtflags mask);
   T3 setbase(int base);
+  template<class charT> T4 setfill(charT c);
   T5 setprecision(int n);
   T6 setw(int n);
   template<class moneyT> T7 get_money(moneyT& mon, bool intl = false);
   template<class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
   template<class charT> T9 get_time(struct tm* tmb, const charT* fmt);
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
+    // types (inherited from basic_ios[ios])
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
     using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
+    // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
     basic_istream<charT, traits>&
       operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
     basic_istream<charT, traits>& seekg(pos_type);
     basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
+    basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
     // [istream.assign], assign and swap
+    basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
   // [istream.extractors], character extraction templates
   template<class traits>
     basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char&);
   template<class traits>
     basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char&);
+  template<class charT, class traits, size_t N>
+    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&, charT(&)[N]);
+  template<class traits, size_t N>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, unsigned char(&)[N]);
+  template<class traits, size_t N>
+    basic_istream<char, traits>& operator>>(basic_istream<char, traits>&, signed char(&)[N]);
 }
 ```
 The class template `basic_istream` defines a number of member function
 signatures that assist in reading and interpreting input from sequences
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
 If `rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`,
 then the input function, except as explicitly noted otherwise, completes
 its actions and does `setstate(eofbit)`, which may throw
+`ios_base::failure` [[iostate.flags]], before returning.
 If one of these called functions throws an exception, then unless
+explicitly noted otherwise, the input function sets `badbit` in the
+error state. If `badbit` is set in `exceptions()`, the input function
+rethrows the exception without completing its actions, otherwise it does
+not throw anything and proceeds as if the called function had returned a
 failure indication.
+##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Initializes the base class subobject with
+`basic_ios::init(sb)` [[basic.ios.cons]].
+*Ensures:* `gcount() == 0`.
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
+*Effects:* Default constructs the base class, copies the `gcount()` from
+`rhs`, calls `basic_ios<charT, traits>::move(rhs)` to initialize the
+base class, and sets the `gcount()` for `rhs` to 0.
 ``` cpp
 virtual ~basic_istream();
 ```
 *Remarks:* Does not perform any operations of `rdbuf()`.
+##### Assignment and swap <a id="istream.assign">[[istream.assign]]</a>
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`. Exchanges the
 values returned by `gcount()` and `rhs.gcount()`.
+##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
     explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).[^19]
 ``` cpp
 ~sentry();
 ```
 ``` cpp
 explicit operator bool() const;
 ```
+*Returns:* `ok_`.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
 of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
 `bool`, the function endeavors to obtain the requested input. If an
+exception is thrown during input then `ios_base::badbit` is turned
+on[^20] in `*this`’s error state. If `(exceptions()&badbit) != 0` then
+the exception is rethrown. In any case, the formatted input function
 destroys the `sentry` object. If no exception has been thrown, it
 returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 operator>>(bool& val);
 operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
+`num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
 described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
 fragment:
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+template<class charT, class traits, size_t N>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT (&s)[N]);
+template<class traits, size_t N>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char (&s)[N]);
+template<class traits, size_t N>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char (&s)[N]);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
+constructed, `operator>>` extracts characters and stores them into `s`.
+If `width()` is greater than zero, `n` is `min(size_t(width()), N)`.
+Otherwise `n` is `N`. `n` is the maximum number of characters stored.
 Characters are extracted and stored until any of the following occurs:
 - `n-1` characters are stored;
 - end of file occurs on the input sequence;
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
 If the function extracted no characters, it calls `setstate(failbit)`,
+which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
 ``` cpp
 basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Behaves as an unformatted input
+function [[istream.unformatted]]. If `sb` is null, calls
+`setstate(failbit)`, which may throw `ios_base::failure`
+[[iostate.flags]]. After a sentry object is constructed, extracts
+characters from `*this` and inserts them in the output sequence
+controlled by `sb`. Characters are extracted and inserted until any of
+the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
 If the function inserts no characters, it calls `setstate(failbit)`,
+which may throw `ios_base::failure` [[iostate.flags]]. If it inserted no
+characters because it caught an exception thrown while extracting
+characters from `*this` and `failbit` is set in `exceptions()`
+[[iostate.flags]], then the caught exception is rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 a value of type `bool`, the function returns without attempting to
 obtain any input. In either case the number of extracted characters is
 set to 0; unformatted input functions taking a character array of
 nonzero size as an argument shall also store a null character (using
 `charT()`) in the first location of the array. If an exception is thrown
+during input then `ios_base::badbit` is turned on[^23] in `*this`’s
+error state. (Exceptions thrown from `basic_ios<>::clear()` are not
+caught or rethrown.) If `(exceptions()&badbit) != 0` then the exception
+is rethrown. It also counts the number of characters extracted. If no
 exception has been thrown it ends by storing the count in a member
 object and returning the value specified. In any event the `sentry`
 object is destroyed before leaving the unformatted input function.
 ``` cpp
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts a character `c`, if
 one is available. Otherwise, the function calls `setstate(failbit)`,
+which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts a character, if one
 is available, and assigns it to `c`.[^24] Otherwise, the function calls
+`setstate(failbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
   calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
 If the function stores no characters, it calls `setstate(failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]). In any case, if
+`n` is greater than zero it then stores a null character into the next
+successive location of the array.
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n);
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
 If the function inserts no characters, it calls `setstate(failbit)`,
+which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
     the function calls `setstate(failbit)`).
 These conditions are tested in the order shown.[^28]
 If the function extracts no characters, it calls `setstate(failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]).[^29]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
 *Effects:* Behaves as an unformatted input function (as described
 above). After constructing a sentry object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
+- `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
 - end-of-file occurs on the input sequence (in which case the function
+  calls `setstate(eofbit)`, which may throw `ios_base::failure`
+  [[iostate.flags]]);
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
 *Remarks:* The last condition will never occur if
 `traits::eq_int_type(delim, traits::eof())`.
 extracted and stored until either of the following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
+  `ios_base::failure` [[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 above). After constructing a sentry object, if `!good()` calls
 `setstate(failbit)` which may throw an exception, and return. Otherwise
 extracts characters and stores them into successive locations of an
 array whose first element is designated by `s`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]), and extracts no characters;
 - If `rdbuf()->in_avail() == 0`, extracts no characters
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
 constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
+calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).
 [*Note 1*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
 constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
+calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`. After constructing a sentry object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
 ``` cpp
 pos_type tellg();
 ```
 *Returns:* `*this`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
+Each instantiation of the function template specified in this subclause
+is a designated addressable function [[namespace.std]].
 ``` cpp
 template<class charT, class traits>
   basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
 ```
+*Effects:* Behaves as an unformatted input
+function [[istream.unformatted]], except that it does not count the
+number of characters extracted and does not affect the value returned by
+subsequent calls to `is.gcount()`. After constructing a sentry object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
+by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
 `failbit`.
 *Returns:* `is`.
 #### Rvalue stream extraction <a id="istream.rvalue">[[istream.rvalue]]</a>
 ``` cpp
+template<class Istream, class T>
+ Istream&& operator>>(Istream&& is, T&& x);
 ```
+*Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
+when treated as an unevaluated operand and `Istream` is publicly and
+unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
+return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     // [iostream.dest], destructor
     virtual ~basic_iostream();
   protected:
     // [iostream.cons], constructor
+    basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
     // [iostream.assign], assign and swap
+    basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ```
 The class template `basic_iostream` inherits a number of functions that
 allow reading input and writing output to sequences controlled by a
 stream buffer.
+##### Constructors <a id="iostream.cons">[[iostream.cons]]</a>
 ``` cpp
 explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Initializes the base class subobjects with
+`basic_istream<charT, traits>(sb)` [[istream]] and
+`basic_ostream<charT, traits>(sb)` [[ostream]].
+*Ensures:* `rdbuf() == sb` and `gcount() == 0`.
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
 `basic_istream` base class with `move(rhs)`.
+##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();
 ```
 *Remarks:* Does not perform any operations on `rdbuf()`.
+##### Assignment and swap <a id="iostream.assign">[[iostream.assign]]</a>
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
+    // types (inherited from basic_ios[ios])
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
     using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
+    // [ostream.sentry], prefix/suffix
     class sentry;
     // [ostream.formatted], formatted output
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
     basic_ostream<charT, traits>& seekp(pos_type);
     basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     // [ostream.cons], copy/move constructor
+    basic_ostream(const basic_ostream&) = delete;
     basic_ostream(basic_ostream&& rhs);
     // [ostream.assign], assign and swap
+    basic_ostream& operator=(const basic_ostream&) = delete;
     basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
   // [ostream.inserters.character], character inserters
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, signed char);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, unsigned char);
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete;
+  template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete;
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const charT*);
   template<class charT, class traits>
     basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, const char*);
   template<class traits>
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const signed char*);
   template<class traits>
     basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const unsigned char*);
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char8_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char16_t*) = delete;
+  template<class traits>
+    basic_ostream<char, traits>&
+      operator<<(basic_ostream<char, traits>&, const char32_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete;
+  template<class traits>
+    basic_ostream<wchar_t, traits>&
+      operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete;
 }
 ```
 The class template `basic_ostream` defines a number of member function
 signatures that assist in formatting and writing output to output
 `rdbuf()->sputc(int_type)`. They may use other public members of
 `basic_ostream` except that they shall not invoke any virtual members of
 `rdbuf()` except `overflow()`, `xsputn()`, and `sync()`.
 If one of these called functions throws an exception, then unless
+explicitly noted otherwise the output function sets `badbit` in the
+error state. If `badbit` is set in `exceptions()`, the output function
+rethrows the exception without completing its actions, otherwise it does
+not throw anything and proceeds as if the called function had returned a
+failure indication.
+[*Note 1*: The deleted overloads of `operator<<` prevent formatting
+characters as integers and strings as pointers. — *end note*]
+##### Constructors <a id="ostream.cons">[[ostream.cons]]</a>
 ``` cpp
 explicit basic_ostream(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Initializes the base class subobject with
+`basic_ios<charT, traits>::init(sb)` [[basic.ios.cons]].
+*Ensures:* `rdbuf() == sb`.
 ``` cpp
 basic_ostream(basic_ostream&& rhs);
 ```
 ``` cpp
 virtual ~basic_ostream();
 ```
 *Remarks:* Does not perform any operations on `rdbuf()`.
+##### Assignment and swap <a id="ostream.assign">[[ostream.assign]]</a>
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
+*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 ```
 *Effects:* Calls `basic_ios<charT, traits>::swap(rhs)`.
+##### Class `basic_ostream::sentry` <a id="ostream.sentry">[[ostream.sentry]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream<charT, traits>::sentry {
 If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^31]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).[^32]
 ``` cpp
 ~sentry();
 ```
 explicit operator bool() const;
 ```
 *Effects:* Returns `ok_`.
+##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 ``` cpp
 Each formatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
 function does `setstate(ios_base::failbit)`, which might throw an
+exception. If an exception is thrown during output, then
+`ios_base::badbit` is turned on[^33] in `*this`’s error state. If
 `(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
 not an exception is thrown, the `sentry` object is destroyed before
 leaving the formatted output function. If no exception is thrown, the
 result of the formatted output function is `*this`.
 ``` cpp
 basic_ostream<charT, traits>& operator<<(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Behaves as an unformatted output
+function [[ostream.unformatted]]. After the sentry object is
+constructed, if `sb` is null calls `setstate(badbit)` (which may throw
 `ios_base::failure`).
 Gets characters from `sb` and inserts them in `*this`. Characters are
 read from `sb` and inserted until any of the following occurs:
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs while getting a character from `sb`.
 If the function inserts no characters, it calls `setstate(failbit)`
+(which may throw `ios_base::failure` [[iostate.flags]]). If an exception
+was thrown while extracting a character, the function sets `failbit` in
+the error state, and if `failbit` is set in `exceptions()` the caught
+exception is rethrown.
 *Returns:* `*this`.
 ``` cpp
 basic_ostream<charT, traits>& operator<<(nullptr_t);
 ``` cpp
 return *this << s;
 ```
+where `s` is an *implementation-defined* NTCTS [[defns.ntcts]].
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, unsigned char c);
 ```
 *Effects:* Behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `out`. Constructs a character
+sequence `seq`. If `c` has type `char` and the character type of the
+stream is not `char`, then `seq` consists of `out.widen(c)`; otherwise
+`seq` consists of `c`. Determines padding for `seq` as described
+in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
+`os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
+*Preconditions:* `s` is not a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
 in  [[ostream.formatted.reqmts]]) of `out`. Creates a character sequence
 `seq` of `n` characters starting at `s`, each widened using
+`out.widen()` [[basic.ios.members]], where `n` is the number that would
+be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
 Each unformatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
+`ios_base::badbit` is turned on[^36] in `*this`’s error state. If
 `(exceptions() & badbit) != 0` then the exception is rethrown. In any
 case, the unformatted output function ends by destroying the sentry
 object, then, if no exception was thrown, returning the value specified
 for the unformatted output function.
 *Effects:* Behaves as an unformatted output function (as described
 above). After constructing a sentry object, inserts the character `c`,
 if possible.[^37]
+Otherwise, calls `setstate(badbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 by `s`.[^38] Characters are inserted until either of the following
 occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
+  calls `setstate(badbit)`, which may throw `ios_base::failure`
+  [[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
 basic_ostream& flush();
 *Effects:* Behaves as an unformatted output function (as described
 above). If `rdbuf()` is not a null pointer, constructs a sentry object.
 If this object returns `true` when converted to a value of type `bool`
 the function calls `rdbuf()->pubsync()`. If that function returns -1
+calls `setstate(badbit)` (which may throw `ios_base::failure`
+[[iostate.flags]]). Otherwise, if the sentry object returns `false`,
+does nothing.
 *Returns:* `*this`.
+#### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
+Each instantiation of any of the function templates specified in this
+subclause is a designated addressable function [[namespace.std]].
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Calls `os.flush()`.
 *Returns:* `os`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>& emit_on_flush(basic_ostream<charT, traits>& os);
+```
+*Effects:* If `os.rdbuf()` is a
+`basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, calls `buf->set_emit_on_sync(true)`. Otherwise this
+manipulator has no effect.
+[*Note 1*: To work around the issue that the `Allocator` template
+argument cannot be deduced, implementations can introduce an
+intermediate base class to `basic_syncbuf` that manages its
+`emit_on_sync` flag. — *end note*]
+*Returns:* `os`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
+```
+*Effects:* If `os.rdbuf()` is a
+`basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, calls `buf->set_emit_on_sync(false)`. Otherwise this
+manipulator has no effect.
+*Returns:* `os`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
+```
+*Effects:* Calls `os.flush()`. Then, if `os.rdbuf()` is a
+`basic_syncbuf<charT, traits, Allocator>*`, called `buf` for the purpose
+of exposition, calls `buf->emit()`.
+*Returns:* `os`.
 #### Rvalue stream insertion <a id="ostream.rvalue">[[ostream.rvalue]]</a>
 ``` cpp
+template<class Ostream, class T>
+ Ostream&& operator<<(Ostream&& os, const T& x);
 ```
+*Constraints:* The expression `os << x` is well-formed when treated as
+an unevaluated operand and `Ostream` is publicly and unambiguously
+derived from `ios_base`.
 *Effects:* As if by: `os << x;`
+*Returns:* `std::move(os)`.
 ### Standard manipulators <a id="std.manip">[[std.manip]]</a>
 The header `<iomanip>` defines several functions that support extractors
 and inserters that alter information maintained by class `ios_base` and
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
 }
 ```
+The expression `out << resetiosflags(mask)` has type
 `basic_ostream<charT, traits>&` and value `out`. The expression
+`in >> resetiosflags(mask)` has type `basic_istream<charT, traits>&` and
+value `in`.
 ``` cpp
 unspecified setiosflags(ios_base::fmtflags mask);
 ```
   // set specified flags
   str.setf(mask);
 }
 ```
+The expression `out << setiosflags(mask)` has type
 `basic_ostream<charT, traits>&` and value `out`. The expression
+`in >> setiosflags(mask)` has type `basic_istream<charT, traits>&` and
+value `in`.
 ``` cpp
 unspecified setbase(int base);
 ```
       base == 16 ? ios_base::hex :
       ios_base::fmtflags(0), ios_base::basefield);
 }
 ```
+The expression `out << setbase(base)` has type
 `basic_ostream<charT, traits>&` and value `out`. The expression
+`in >> setbase(base)` has type `basic_istream<charT, traits>&` and value
+`in`.
 ``` cpp
 unspecified setfill(char_type c);
 ```
   // set fill character
   str.fill(c);
 }
 ```
+The expression `out << setfill(c)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 unspecified setprecision(int n);
 ```
   // set precision
   str.precision(n);
 }
 ```
+The expression `out << setprecision(n)` has type
 `basic_ostream<charT, traits>&` and value `out`. The expression
+`in >> setprecision(n)` has type `basic_istream<charT, traits>&` and
+value `in`.
 ``` cpp
 unspecified setw(int n);
 ```
   // set width
   str.width(n);
 }
 ```
+The expression `out << setw(n)` has type `basic_ostream<charT, traits>&`
+and value `out`. The expression `in >> setw(n)` has type
+`basic_istream<charT, traits>&` and value `in`.
 ### Extended manipulators <a id="ext.manip">[[ext.manip]]</a>
 The header `<iomanip>` defines several functions that support extractors
 and inserters that allow for the parsing and formatting of sequences and
 ``` cpp
 template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
 ```
+*Mandates:* The type `moneyT` is either `long double` or a
+specialization of the `basic_string` template [[strings]].
 *Effects:* The expression `in >> get_money(mon, intl)` described below
+behaves as a formatted input function [[istream.formatted.reqmts]].
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_money(mon, intl)` behaves as if it called `f(in, mon, intl)`,
 where the function `f` is defined as:
   if (ios_base::goodbit != err)
     str.setstate(err);
 }
 ```
+The expression `in >> get_money(mon, intl)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
 template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
 ```
+*Mandates:* The type `moneyT` is either `long double` or a
+specialization of the `basic_string` template [[strings]].
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_money(mon, intl)` behaves as a formatted output
+function [[ostream.formatted.reqmts]] that calls `f(out, mon, intl)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
   const MoneyPut& mp = use_facet<MoneyPut>(str.getloc());
   const Iter end = mp.put(Iter(str.rdbuf()), intl, str, str.fill(), mon);
   if (end.failed())
+    str.setstate(ios_base::badbit);
 }
 ```
+The expression `out << put_money(mon, intl)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 template<class charT> unspecified get_time(struct tm* tmb, const charT* fmt);
 ```
+*Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
+is a valid range.
 *Returns:* An object of unspecified type such that if `in` is an object
 of type `basic_istream<charT, traits>` then the expression
 `in >> get_time(tmb, fmt)` behaves as if it called `f(in, tmb, fmt)`,
 where the function `f` is defined as:
   if (err != ios_base::goodbit)
     str.setstate(err);
 }
 ```
+The expression `in >> get_time(tmb, fmt)` has type
 `basic_istream<charT, traits>&` and value `in`.
 ``` cpp
 template<class charT> unspecified put_time(const struct tm* tmb, const charT* fmt);
 ```
+*Preconditions:* The argument `tmb` is a valid pointer to an object of
+type `struct tm`, and \[`fmt`, `fmt + char_traits<charT>::length(fmt)`)
+is a valid range.
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << put_time(tmb, fmt)` behaves as if it called `f(out, tmb, fmt)`,
 where the function `f` is defined as:
   if (end.failed())
     str.setstate(ios_base::badbit);
 }
 ```
+The expression `out << put_time(tmb, fmt)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ### Quoted manipulators <a id="quoted.manip">[[quoted.manip]]</a>
 [*Note 1*: Quoted manipulators provide string insertion and extraction
 *Returns:* An object of unspecified type such that if `out` is an
 instance of `basic_ostream` with member type `char_type` the same as
 `charT` and with member type `traits_type`, which in the second and
 third forms is the same as `traits`, then the expression
 `out << quoted(s, delim, escape)` behaves as a formatted output
+function [[ostream.formatted.reqmts]] of `out`. This forms a character
+sequence `seq`, initially consisting of the following elements:
 - `delim`.
 - Each character in `s`. If the character to be output is equal to
   `escape` or `delim`, as determined by `traits_type::eq`, first output
   `escape`.
 Let `x` be the number of elements initially in `seq`. Then padding is
 determined for `seq` as described in  [[ostream.formatted.reqmts]],
 `seq` is inserted as if by calling `out.rdbuf()->sputn(seq, n)`, where
 `n` is the larger of `out.width()` and `x`, and `out.width(0)` is
+called. The expression `out << quoted(s, delim, escape)` has type
 `basic_ostream<charT, traits>&` and value `out`.
 ``` cpp
 template<class charT, class traits, class Allocator>
   unspecified quoted(basic_string<charT, traits, Allocator>& s,
 - If `in` is an instance of `basic_istream` with member types
   `char_type` and `traits_type` the same as `charT` and `traits`,
   respectively, then the expression `in >> quoted(s, delim, escape)`
   behaves as if it extracts the following characters from `in` using
+  `operator>>(basic_istream<charT, traits>&, charT&)`
+ [[istream.extractors]] which may throw `ios_base::failure`
+  [[ios.failure]]:
   - If the first character extracted is equal to `delim`, as determined
     by `traits_type::eq`, then:
     - Turn off the `skipws` flag.
     - `s.clear()`
     - Until an unescaped `delim` character is reached or `!in`, extract
   `char_type` and `traits_type` the same as `charT` and `traits`,
   respectively, then the expression `out << quoted(s, delim, escape)`
   behaves as specified for the
   `const basic_string<charT, traits, Allocator>&` overload of the
   `quoted` function.
+- The expression `in >> quoted(s, delim, escape)` has type
+ `basic_istream<charT, traits>&` and value `in`.
+- The expression `out << quoted(s, delim, escape)` has type
   `basic_ostream<charT, traits>&` and value `out`.

Diff to HTML by rtfpessoa