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

Files changed (1) hide show

tmp/tmp0hqgflvw/{from.md → to.md} +425 -416

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

@@ -1,52 +1,55 @@
 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
-### Overview <a id="iostream.format.overview">[[iostream.format.overview]]</a>
-\synopsis{Header \texttt{\<istream\>} synopsis}
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_istream;
-  typedef basic_istream<char>     istream;
- typedef basic_istream<wchar_t> wistream;
   template <class charT, class traits = char_traits<charT>>
     class basic_iostream;
-  typedef basic_iostream<char>    iostream;
- typedef basic_iostream<wchar_t> wiostream;
   template <class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
   template <class charT, class traits, class T>
-    basic_istream<charT, traits>&
-    operator>>(basic_istream<charT, traits>&& is, T& x);
 }
 ```
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_ostream;
-  typedef basic_ostream<char>     ostream;
- typedef basic_ostream<wchar_t> wostream;
   template <class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   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);
 }
 ```
 ``` cpp
 namespace std {
   // types T1, T2, ... are unspecified implementation types
   T1 resetiosflags(ios_base::fmtflags mask);
   T2 setiosflags  (ios_base::fmtflags mask);
@@ -62,15 +65,19 @@ namespace std {
   template <class charT>
     T11 quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template <class charT, class traits, class Allocator>
     T12 quoted(const basic_string<charT, traits, Allocator>& s,
- charT delim=charT('"'), charT escape=charT('\\'));
   template <class charT, class traits, class Allocator>
     T13 quoted(basic_string<charT, traits, Allocator>& s,
- charT delim=charT('"'), charT escape=charT('\\'));
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
@@ -84,30 +91,30 @@ extracts from stream rvalues.
 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])):
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [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>& operator>>(
- basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
-    basic_istream<charT,traits>& operator>>(
-      ios_base& (*pf)(ios_base&));
     basic_istream<charT, traits>& operator>>(bool& n);
     basic_istream<charT, traits>& operator>>(short& n);
     basic_istream<charT, traits>& operator>>(unsigned short& n);
     basic_istream<charT, traits>& operator>>(int& n);
@@ -119,30 +126,25 @@ namespace std {
     basic_istream<charT, traits>& operator>>(float& f);
     basic_istream<charT, traits>& operator>>(double& f);
     basic_istream<charT, traits>& operator>>(long double& f);
     basic_istream<charT, traits>& operator>>(void*& p);
-    basic_istream<charT,traits>& operator>>(
-      basic_streambuf<char_type,traits>* sb);
-    // [istream.unformatted] Unformatted input:
     streamsize gcount() const;
     int_type get();
     basic_istream<charT, traits>& get(char_type& c);
     basic_istream<charT, traits>& get(char_type* s, streamsize n);
-    basic_istream<charT,traits>& get(char_type* s, streamsize n,
-                                     char_type delim);
     basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
-    basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
-                                    char_type delim);
     basic_istream<charT, traits>& getline(char_type* s, streamsize n);
-    basic_istream<charT,traits>& getline(char_type* s, streamsize n,
-                                         char_type delim);
-    basic_istream<charT,traits>& ignore(
-      streamsize n = 1, int_type delim = traits::eof());
     int_type                      peek();
     basic_istream<charT, traits>& read    (char_type* s, streamsize n);
     streamsize                    readsome(char_type* s, streamsize n);
     basic_istream<charT, traits>& putback(char_type c);
@@ -152,45 +154,40 @@ namespace std {
     pos_type tellg();
     basic_istream<charT, traits>& seekg(pos_type);
     basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     basic_istream(const basic_istream& rhs) = delete;
     basic_istream(basic_istream&& rhs);
-    // [istream.assign] Assign/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:
   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&);
   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 `basic_istream` defines a number of member function signatures
-that assist in reading and interpreting input from sequences controlled
-by a stream buffer.
 Two groups of member function signatures share common properties: the
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
@@ -212,15 +209,15 @@ failure indication.
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_istream`, assigning
-initial values to the base class by calling
 `basic_ios::init(sb)` ([[basic.ios.cons]]).
-`gcount() == 0`
 ``` cpp
 basic_istream(basic_istream&& rhs);
 ```
@@ -241,11 +238,11 @@ virtual ~basic_istream();
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* `swap(rhs);`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
@@ -258,11 +255,11 @@ values returned by `gcount()` and `rhs.gcount()`.
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
- typedef traits traits_type;
     bool ok_; // exposition only
   public:
     explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
@@ -285,19 +282,23 @@ Otherwise, prepares for formatted or unformatted input. First, if
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
-`flush` may be eliminated entirely.[^17] If `noskipws` is zero and
 `is.flags() & ios_base::skipws` is nonzero, the function extracts and
 discards each character as long as the next available input character
 `c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
 `is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
 `setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
 *Remarks:* The constructor
-`explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false)`
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
 To decide if the character `c` is a whitespace character, the
 constructor performs as if it executes the following code fragment:
@@ -309,11 +310,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]]))[^18]
 ``` cpp
 ~sentry();
 ```
@@ -331,11 +332,11 @@ explicit operator bool() const;
 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[^19] 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`.
@@ -361,32 +362,36 @@ 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:
 ``` cpp
-typedef num_get< charT,istreambuf_iterator<charT,traits> > numget;
 iostate err = iostate::goodbit;
 use_facet<numget>(loc).get(*this, 0, *this, err, val);
 setstate(err);
 ```
 In the above fragment, `loc` stands for the private member of the
-`basic_ios` class. The first argument provides an object of the
 `istreambuf_iterator` class which is an iterator pointed to an input
-stream. It bypasses istreams and uses streambufs directly. Class
-`locale` relies on this type as its interface to `istream`, so that it
-does not need to depend directly on `istream`.
 ``` cpp
 operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
-typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
 iostate err = ios_base::goodbit;
 long lval;
 use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<short>::min()) {
   err |= ios_base::failbit;
@@ -405,11 +410,11 @@ operator>>(int& val);
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
-typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
 iostate err = ios_base::goodbit;
 long lval;
 use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<int>::min()) {
   err |= ios_base::failbit;
@@ -420,54 +425,50 @@ if (lval < numeric_limits<int>::min()) {
 }  else
   val = static_cast<int>(lval);
 setstate(err);
 ```
-##### `basic_istream::operator>>` <a id="istream::extractors">[[istream::extractors]]</a>
 ``` cpp
-basic_istream<charT,traits>& operator>>
- (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
-function (as described in  [[istream.formatted.reqmts]].)
-*Returns:* `pf(*this)`.[^20]
 ``` cpp
-basic_istream<charT,traits>& operator>>
- (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT,traits>& operator>>
-    (ios_base& (*pf)(ios_base&));
 ```
-*Effects:* Calls `pf(*this)`.[^21] This extractor does not behave as a
 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
@@ -479,12 +480,12 @@ 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;
-- `ct.is(ct.space,c)` is `true` for the next available input character
-  `c`, where `ct` is `use_facet<ctype<charT> >(in.getloc())`.
 `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)`.
@@ -493,38 +494,33 @@ which may throw `ios_base::failure` ([[iostate.flags]]).
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
-  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>& in,
-                                          charT& c);
 template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
-                                         unsigned char& c);
 template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>& in,
-                                         signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
 constructed a character is extracted from `in`, if one is available, and
 stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 *Returns:* `in`.
 ``` cpp
-basic_istream<charT,traits>& operator>>
-  (basic_streambuf<charT,traits>* sb);
 ```
-*Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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);
@@ -544,18 +540,18 @@ rethrown.
 Each unformatted input function begins execution by constructing an
 object of class `sentry` with the default argument `noskipws` (second)
 argument `true`. If the `sentry` object returns `true`, when converted
 to a value of type `bool`, the function endeavors to obtain the
 requested input. Otherwise, if the sentry constructor exits by throwing
-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 non-zero 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[^22] 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.
@@ -563,49 +559,47 @@ object is destroyed before leaving the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
-input function (as described in  [[istream.unformatted]], paragraph 1).
 *Returns:* The number of characters extracted by the last unformatted
 input member function called for the object.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts a character, if one is available, and assigns it to
-`c`.[^23] 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 );
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts characters and stores them into successive locations of
-an array whose first element is designated by `s`.[^24] Characters are
-extracted and stored until any of the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
@@ -620,24 +614,22 @@ next successive location of the array.
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n);
 ```
-*Effects:* Calls `get(s,n,widen(’\n’))`
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
-                  char_type delim );
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts characters 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);
 - `traits::eq(c, delim)` for the next available input character `c` (in
@@ -652,44 +644,45 @@ which may throw `ios_base::failure` ([[iostate.flags]]).
 ``` cpp
 basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
 ```
-*Effects:* Calls `get(sb, widen(’\n’))`
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT,traits>& getline(char_type* s, streamsize n,
-                      char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts characters and stores them into successive locations of
-an array whose first element is designated by `s`.[^25] Characters are
-extracted and stored until one of the following occurs:
 1.  end-of-file occurs on the input sequence (in which case the function
     calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
-    stored);[^26]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
-These conditions are tested in the order shown.[^27]
 If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])).[^28]
 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.
 *Returns:* `*this`.
 ``` cpp
 #include <iostream>
 int main() {
   using namespace std;
@@ -711,27 +704,28 @@ int main() {
     cout << " (" << count << " chars): " << buffer << endl;
   }
 }
 ```
 ``` cpp
 basic_istream<charT, traits>& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
-basic_istream<charT,traits>&
-    ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, extracts characters and discards them. Characters are extracted
-until any of the following occurs:
-- `n != numeric_limits<streamsize>::max()` ([[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
@@ -745,27 +739,26 @@ until any of the following occurs:
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). After constructing a sentry
-object, reads but does not extract the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
 basic_istream<charT, traits>& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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`.[^29] 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]])).
@@ -775,17 +768,16 @@ following occurs:
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1). 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.
@@ -793,86 +785,87 @@ characters;
 ``` cpp
 basic_istream<charT, traits>& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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]])). This
-function extracts no characters, so the value returned by the next call
-to `gcount()` is 0.
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& unget();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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]])). This
-function extracts no characters, so the value returned by the next call
-to `gcount()` is 0.
 *Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), except that it does not count
-the number of characters extracted and does not affect the value
-returned by subsequent calls to `gcount()`.
 *Returns:* After constructing a sentry object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
 basic_istream<charT, traits>& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), except that the function
-first clears `eofbit`, it does not count the number of characters
-extracted, and it does not affect the value returned by subsequent calls
-to `gcount()`. After constructing a sentry object, if `fail() != true`,
-executes `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure,
-the function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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 `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
@@ -880,77 +873,94 @@ function calls `setstate(failbit)` (which may throw
 *Returns:* `*this`.
 #### Standard `basic_istream` manipulators <a id="istream.manip">[[istream.manip]]</a>
 ``` cpp
-namespace std {
 template <class charT, class traits>
   basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
-}
 ```
-*Effects:* Behaves as an unformatted input function (as described
-in  [[istream.unformatted]], paragraph 1), 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`.
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
-  class basic_iostream :
-    public basic_istream<charT,traits>,
       public basic_ostream<charT, traits> {
   public:
- // types:
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
-    typedef traits                    traits_type;
-    // constructor/destructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_iostream();
   protected:
     basic_iostream(const basic_iostream& rhs) = delete;
     basic_iostream(basic_iostream&& rhs);
-    // assign/swap
     basic_iostream& operator=(const basic_iostream& rhs) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ```
-The class `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`, assigning
-initial values to the base classes by calling
 `basic_istream<charT, traits>(sb)` ([[istream]]) and
-`basic_ostream<charT,traits>(sb)` ([[ostream]])
-`rdbuf()==sb` and `gcount()==0`.
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
@@ -971,30 +981,18 @@ virtual ~basic_iostream();
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
-#### 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:* `is >>x`
-*Returns:* `is`
 ### Output streams <a id="output.streams">[[output.streams]]</a>
 The header `<ostream>` defines a type and several function signatures
 that control output to a stream buffer along with a function template
 that inserts into stream rvalues.
@@ -1005,30 +1003,30 @@ that inserts into stream rvalues.
 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])):
- typedef charT                     char_type;
- typedef typename traits::int_type int_type;
- typedef typename traits::pos_type pos_type;
- typedef typename traits::off_type off_type;
- typedef traits                    traits_type;
-    // [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>& operator<<(
-      basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
-    basic_ostream<charT,traits>& operator<<(
-      ios_base& (*pf)(ios_base&));
     basic_ostream<charT, traits>& operator<<(bool n);
     basic_ostream<charT, traits>& operator<<(short n);
     basic_ostream<charT, traits>& operator<<(unsigned short n);
     basic_ostream<charT, traits>& operator<<(int n);
@@ -1040,75 +1038,65 @@ namespace std {
     basic_ostream<charT, traits>& operator<<(float f);
     basic_ostream<charT, traits>& operator<<(double f);
     basic_ostream<charT, traits>& operator<<(long double f);
     basic_ostream<charT, traits>& operator<<(const void* p);
-    basic_ostream<charT,traits>& operator<<(
- basic_streambuf<char_type,traits>* sb);
-    // [ostream.unformatted] Unformatted output:
     basic_ostream<charT, traits>& put(char_type c);
     basic_ostream<charT, traits>& write(const char_type* s, streamsize n);
     basic_ostream<charT, traits>& flush();
-    // [ostream.seeks] seeks:
     pos_type tellp();
     basic_ostream<charT, traits>& seekp(pos_type);
     basic_ostream<charT, traits>& seekp(off_type, ios_base::seekdir);
   protected:
     basic_ostream(const basic_ostream& rhs) = delete;
     basic_ostream(basic_ostream&& rhs);
-    // [ostream.assign] Assign/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
   template<class charT, class traits>
-    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                            charT);
   template<class charT, class traits>
-    basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&,
-                                            char);
   template<class traits>
-    basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                           char);
-  // signed and unsigned
   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>
-    basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&,
-                                           const char*);
-  // signed and unsigned
   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 `basic_ostream` defines a number of member function signatures
-that assist in formatting and writing output to output sequences
-controlled by a stream buffer.
 Two groups of member function signatures share common properties: the
 *formatted output functions* (or *inserters*) and the *unformatted
 output functions.* Both groups of output functions generate (or
 *insert*) output *characters* by actions equivalent to calling
@@ -1120,45 +1108,55 @@ 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);
 ```
-``` cpp
-virtual ~basic_ostream();
-```
 ``` cpp
 basic_ostream(basic_ostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by default constructing the base class and calling
 `basic_ios<charT, traits>::move(rhs)` to initialize the base class.
-#### Class `basic_ostream` assign and swap <a id="ostream.assign">[[ostream.assign]]</a>
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
-*Effects:* `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 {
@@ -1180,45 +1178,55 @@ exception safe prefix and suffix operations.
 ``` cpp
 explicit sentry(basic_ostream<charT, traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
-If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^30]
 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]]))[^31]
 ``` cpp
 ~sentry();
 ```
 If
-`((os.flags() & ios_base::unitbuf) && !uncaught_exception() && os.good())`
 is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1,
 sets `badbit` in `os.rdstate()` without propagating an exception.
 ``` cpp
 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
 pos_type tellp();
 ```
 ``` cpp
 basic_ostream<charT, traits>& seekp(pos_type pos);
 ```
 ``` cpp
 basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
@@ -1236,11 +1244,11 @@ 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[^32] 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`.
@@ -1337,59 +1345,57 @@ bool failed = use_facet<
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
 these types as its interface to iostreams, since for flexibility it has
 been abstracted away from direct dependence on `ostream`. The second
-parameter is a reference to the base subobject of type `ios_base`. It
-provides formatting specifications such as field width, and a locale
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
-basic_ostream<charT,traits>& operator<<
- (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^33]
 ``` cpp
-basic_ostream<charT,traits>& operator<<
- (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
-*Returns:* `*this`.[^34]
 ``` cpp
-basic_ostream<charT,traits>& operator<<
-    (ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_ostream<charT,traits>& operator<<
-    (basic_streambuf<charT,traits>* sb);
 ```
-*Effects:* Behaves as an unformatted output function (as described
-in  [[ostream.unformatted]], paragraph 1). 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:
@@ -1404,55 +1410,58 @@ 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`.
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
-  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
-                                          charT c);
 template<class charT, class traits>
-  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
-                                          char c);
 // specialization
 template<class traits>
-  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
-                                         char c);
 // signed and unsigned
 template<class traits>
-  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
-                                         signed char c);
 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>
-  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
-                                          const charT* s);
 template<class charT, class traits>
-  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
-                                          const char* s);
 template<class traits>
-  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
-                                         const char* s);
 template<class traits>
-  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
-                                         const signed char* s);
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
@@ -1467,11 +1476,11 @@ 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
   `const char*`,
-- `std::char_traits<char>::length(s)` for the overload where the first
   argument is of type `basic_ostream<charT, traits>&` and the second is
   of type `const char*`,
 - `traits::length(reinterpret_cast<const char*>(s))` for the other two
   overloads.
@@ -1485,23 +1494,23 @@ 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[^35] 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.
 ``` cpp
 basic_ostream<charT, traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
-object, inserts the character `c`, if possible.[^36]
 Otherwise, calls `setstate(badbit)` (which may throw
 `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
@@ -1509,14 +1518,14 @@ Otherwise, calls `setstate(badbit)` (which may throw
 ``` cpp
 basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
-in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
-object, obtains characters to insert from successive locations of an
-array whose first element is designated by `s`.[^37] 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]])).
@@ -1526,67 +1535,62 @@ inserted until either of the following occurs:
 ``` cpp
 basic_ostream& flush();
 ```
 *Effects:* Behaves as an unformatted output function (as described
-in  [[ostream.formatted.reqmts]], paragraph 1). 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
-namespace std {
 template <class charT, class traits>
   basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
-}
 ```
 *Effects:* Calls `os.put(os.widen(’\n’))`, then `os.flush()`.
 *Returns:* `os`.
 ``` cpp
-namespace std {
 template <class charT, class traits>
   basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
-}
 ```
 *Effects:* Inserts a null character into the output sequence: calls
 `os.put(charT())`.
 *Returns:* `os`.
 ``` cpp
-namespace std {
 template <class charT, class traits>
   basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);
-}
 ```
 *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:* `os << x`
-*Returns:* `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
@@ -1596,59 +1600,59 @@ its derived classes.
 unspecified resetiosflags(ios_base::fmtflags mask);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
-`out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
-expression `in >> resetiosflags(mask)` behaves as if it called
-`f(in, mask)`, where the function `f` is defined as:[^38]
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
-`out << setiosflags(mask)` behaves as if it called `f(out, mask)`, or if
 `in` is an object of type `basic_istream<charT, traits>` then the
-expression `in >> setiosflags(mask)` behaves as if it called
 `f(in, mask)`, where the function `f` is defined as:
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
-`out << setbase(base)` behaves as if it called `f(out, base)`, or if
 `in` is an object of type `basic_istream<charT, traits>` then the
-expression `in >> setbase(base)` behaves as if it called `f(in, base)`,
 where the function `f` is defined as:
 ``` cpp
 void f(ios_base& str, int base) {
   // set basefield
@@ -1657,79 +1661,79 @@ 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` and `c` has type `charT` then the
-expression `out << setfill(c)` behaves as if it called `f(out, c)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
-`out << setprecision(n)` behaves as if it called `f(out, n)`, or if `in`
 is an object of type `basic_istream<charT, traits>` then the expression
-`in >> setprecision(n)` behaves as if it called `f(in, n)`, where the
 function `f` is defined as:
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an
 instance of `basic_ostream<charT, traits>` then the expression
-`out << setw(n)` behaves as if it called `f(out, n)`, or if `in` is an
 object of type `basic_istream<charT, traits>` then the expression
-`in >> setw(n)` behaves as if it called `f(in, n)`, where the function
 `f` is defined as:
 ``` cpp
 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
@@ -1746,18 +1750,18 @@ 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:
 ``` cpp
 template <class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
- typedef istreambuf_iterator<charT, traits> Iter;
- typedef money_get<charT, Iter> MoneyGet;
   ios_base::iostate err = ios_base::goodbit;
   const MoneyGet& mg = use_facet<MoneyGet>(str.getloc());
   mg.get(Iter(str.rdbuf()), Iter(), intl, str, err, mon);
@@ -1765,11 +1769,11 @@ 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);
 ```
@@ -1777,62 +1781,63 @@ template <class moneyT> unspecified put_money(const moneyT& mon, bool intl = fal
 *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 input function 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) {
- typedef ostreambuf_iterator<charT, traits> Iter;
- typedef money_put<charT, Iter> MoneyPut;
   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`, 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 `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:
 ``` cpp
 template <class charT, class traits>
 void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
- typedef istreambuf_iterator<charT, traits> Iter;
- typedef time_get<charT, Iter> TimeGet;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
   tg.get(Iter(str.rdbuf()), Iter(), str, err, tmb,
     fmt, fmt + traits::length(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);
 ```
@@ -1842,51 +1847,55 @@ 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:
 ``` cpp
 template <class charT, class traits>
 void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
- typedef ostreambuf_iterator<charT, traits> Iter;
- typedef time_put<charT, Iter> TimePut;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
     fmt, fmt + traits::length(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>
-Quoted manipulators provide string insertion and extraction of quoted
-strings (for example, XML and CSV formats). Quoted manipulators are
-useful in ensuring that the content of a string with embedded spaces
-remains unchanged if inserted and then extracted via stream I/O.
 ``` cpp
 template <class charT>
   unspecified quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
 template <class charT, class traits, class Allocator>
   unspecified quoted(const basic_string<charT, traits, Allocator>& s,
- charT delim=charT('"'), charT escape=charT('\\'));
 ```
 *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 form 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`.
@@ -1897,45 +1906,45 @@ 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,
- charT delim=charT('"'), charT escape=charT('\\'));
 ```
 *Returns:* An object of unspecified type such that:
 - 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
-  `basic_istream::operator>>` ([[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
       characters from `in` and append them to `s`, except that if an
       `escape` is reached, ignore it and append the next character to
       `s`.
     - Discard the final `delim` character.
     - Restore the `skipws` flag to its original value.
-  - Otherwise, `in >> s`.
 - If `out` is an instance of `basic_ostream` with member types
   `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`.

 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
+### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_istream;
+ using istream  = basic_istream<char>;
+  using wistream = basic_istream<wchar_t>;
   template <class charT, class traits = char_traits<charT>>
     class basic_iostream;
+ using iostream  = basic_iostream<char>;
+  using wiostream = basic_iostream<wchar_t>;
   template <class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
   template <class charT, class traits, class T>
+    basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>&& is, T&& x);
 }
 ```
+### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
     class basic_ostream;
+ using ostream  = basic_ostream<char>;
+  using wostream = basic_ostream<wchar_t>;
   template <class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   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);
 }
 ```
+### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
   // types T1, T2, ... are unspecified implementation types
   T1 resetiosflags(ios_base::fmtflags mask);
   T2 setiosflags  (ios_base::fmtflags mask);
   template <class charT>
     T11 quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
   template <class charT, class traits, class Allocator>
     T12 quoted(const basic_string<charT, traits, Allocator>& s,
+    \itcorr           charT delim = charT('"'), charT escape = charT('\\'));
   template <class charT, class traits, class Allocator>
     T13 quoted(basic_string<charT, traits, Allocator>& s,
+    \itcorr           charT delim = charT('"'), charT escape = charT('\\'));
+  template <class charT, class traits>
+    T14 quoted(basic_string_view<charT, traits> s,
+    \itcorr           charT delim = charT('"'), charT escape = charT('\\'));
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
 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>&
+      operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_istream<charT, traits>&
+ operator>>(ios_base& (*pf)(ios_base&));
     basic_istream<charT, traits>& operator>>(bool& n);
     basic_istream<charT, traits>& operator>>(short& n);
     basic_istream<charT, traits>& operator>>(unsigned short& n);
     basic_istream<charT, traits>& operator>>(int& n);
     basic_istream<charT, traits>& operator>>(float& f);
     basic_istream<charT, traits>& operator>>(double& f);
     basic_istream<charT, traits>& operator>>(long double& f);
     basic_istream<charT, traits>& operator>>(void*& p);
+    basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);
+    // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
     basic_istream<charT, traits>& get(char_type& c);
     basic_istream<charT, traits>& get(char_type* s, streamsize n);
+    basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
     basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
+    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
     basic_istream<charT, traits>& getline(char_type* s, streamsize n);
+    basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
+    basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type                      peek();
     basic_istream<charT, traits>& read    (char_type* s, streamsize n);
     streamsize                    readsome(char_type* s, streamsize n);
     basic_istream<charT, traits>& putback(char_type c);
     pos_type tellg();
     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
   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&);
   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
+controlled by a stream buffer.
 Two groups of member function signatures share common properties: the
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 ``` 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);
 ```
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* As if by `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 ``` 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_; }
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
+`flush` may be eliminated entirely.[^18] If `noskipws` is zero and
 `is.flags() & ios_base::skipws` is nonzero, the function extracts and
 discards each character as long as the next available input character
 `c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
 `is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
 `setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
 *Remarks:* The constructor
+``` cpp
+explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false)
+```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
 To decide if the character `c` is a whitespace character, the
 constructor performs as if it executes the following code fragment:
 ```
 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();
 ```
 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`.
 described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
 fragment:
 ``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 iostate err = iostate::goodbit;
 use_facet<numget>(loc).get(*this, 0, *this, err, val);
 setstate(err);
 ```
 In the above fragment, `loc` stands for the private member of the
+`basic_ios` class.
+[*Note 1*: The first argument provides an object of the
 `istreambuf_iterator` class which is an iterator pointed to an input
+stream. It bypasses istreams and uses streambufs
+directly. — *end note*]
+Class `locale` relies on this type as its interface to `istream`, so
+that it does not need to depend directly on `istream`.
 ``` cpp
 operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 iostate err = ios_base::goodbit;
 long lval;
 use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<short>::min()) {
   err |= ios_base::failbit;
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 iostate err = ios_base::goodbit;
 long lval;
 use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<int>::min()) {
   err |= ios_base::failbit;
 }  else
   val = static_cast<int>(lval);
 setstate(err);
 ```
+##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
+basic_istream<charT, traits>&
+  operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
+function (as described in  [[istream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^21]
 ``` cpp
+basic_istream<charT, traits>&
+  operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_istream<charT, traits>& operator>>(ios_base& (*pf)(ios_base&));
 ```
+*Effects:* Calls `pf(*this)`.[^22] This extractor does not behave as a
 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
 Characters are extracted and stored until any of the following occurs:
 - `n-1` characters are stored;
 - end of file occurs on the input sequence;
+- letting `ct` be `use_facet<ctype<charT>>(in.getloc())`,
+  `ct.is(ct.space, c)` is `true`.
 `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)`.
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
+  basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& in, charT& c);
 template<class traits>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, unsigned char& c);
 template<class traits>
+  basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
 in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
 constructed a character is extracted from `in`, if one is available, and
 stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 *Returns:* `in`.
 ``` 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);
 Each unformatted input function begins execution by constructing an
 object of class `sentry` with the default argument `noskipws` (second)
 argument `true`. If the `sentry` object returns `true`, when converted
 to a value of type `bool`, the function endeavors to obtain the
 requested input. Otherwise, if the sentry constructor exits by throwing
+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
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
+input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
 input member function called for the object.
 ``` cpp
 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);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a sentry object, extracts characters and
+stores them into successive locations of an array whose first element is
+designated by `s`.[^25] Characters are extracted and stored until any of
+the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
 ``` cpp
 basic_istream<charT, traits>& get(char_type* s, streamsize n);
 ```
+*Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a sentry object, extracts characters 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);
 - `traits::eq(c, delim)` for the next available input character `c` (in
 ``` cpp
 basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
 ```
+*Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a sentry object, extracts characters and
+stores them into successive locations of an array whose first element is
+designated by `s`.[^26] Characters are extracted and stored until one of
+the following occurs:
 1.  end-of-file occurs on the input sequence (in which case the function
     calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
+    stored);[^27]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     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.
 *Returns:* `*this`.
+[*Example 1*:
 ``` cpp
 #include <iostream>
 int main() {
   using namespace std;
     cout << " (" << count << " chars): " << buffer << endl;
   }
 }
 ```
+— *end example*]
 ``` cpp
 basic_istream<charT, traits>& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
+basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *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
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a sentry object, reads but does not extract
+the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
 basic_istream<charT, traits>& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+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`.[^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]])).
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+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.
 ``` cpp
 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`.
 ``` cpp
 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`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+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();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above), except that it does not count the number of characters extracted
+and does not affect the value returned by subsequent calls to
+`gcount()`.
 *Returns:* After constructing a sentry object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
 basic_istream<charT, traits>& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above), except that the function first clears `eofbit`, it does not
+count the number of characters extracted, and it does not affect the
+value returned by subsequent calls to `gcount()`. After constructing a
+sentry object, if `fail() != true`, executes
+`rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
+function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
 basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above), except that the function first clears `eofbit`, 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 `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *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>>
+  class basic_iostream
+ : public basic_istream<charT, traits>,
       public basic_ostream<charT, traits> {
   public:
+ 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;
+    // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
+    // [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);
 ```
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* As if by `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
 *Effects:* Calls `basic_istream<charT, traits>::swap(rhs)`.
 ### Output streams <a id="output.streams">[[output.streams]]</a>
 The header `<ostream>` defines a type and several function signatures
 that control output to a stream buffer along with a function template
 that inserts into stream rvalues.
 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>&
+ operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_ostream<charT, traits>&
+ operator<<(ios_base& (*pf)(ios_base&));
     basic_ostream<charT, traits>& operator<<(bool n);
     basic_ostream<charT, traits>& operator<<(short n);
     basic_ostream<charT, traits>& operator<<(unsigned short n);
     basic_ostream<charT, traits>& operator<<(int n);
     basic_ostream<charT, traits>& operator<<(float f);
     basic_ostream<charT, traits>& operator<<(double f);
     basic_ostream<charT, traits>& operator<<(long double f);
     basic_ostream<charT, traits>& operator<<(const void* p);
+    basic_ostream<charT, traits>& operator<<(nullptr_t);
+    basic_ostream<charT, traits>& operator<<(basic_streambuf<char_type, traits>* sb);
+    // [ostream.unformatted], unformatted output
     basic_ostream<charT, traits>& put(char_type c);
     basic_ostream<charT, traits>& write(const char_type* s, streamsize n);
     basic_ostream<charT, traits>& flush();
+    // [ostream.seeks], seeks
     pos_type tellp();
     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
   template<class charT, class traits>
+    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, charT);
   template<class charT, class traits>
+    basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>&, char);
   template<class traits>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char);
   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>
+    basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char*);
   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
+sequences controlled by a stream buffer.
 Two groups of member function signatures share common properties: the
 *formatted output functions* (or *inserters*) and the *unformatted
 output functions.* Both groups of output functions generate (or
 *insert*) output *characters* by actions equivalent to calling
 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);
 ```
 *Effects:* Move constructs from the rvalue `rhs`. This is accomplished
 by default constructing the base class and calling
 `basic_ios<charT, traits>::move(rhs)` to initialize the base class.
+``` 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 {
 ``` cpp
 explicit sentry(basic_ostream<charT, traits>& os);
 ```
 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();
 ```
 If
+`(os.flags() & ios_base::unitbuf) && !uncaught_exceptions() && os.good()`
 is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1,
 sets `badbit` in `os.rdstate()` without propagating an exception.
 ``` cpp
 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
 pos_type tellp();
 ```
+*Returns:* If `fail() != false`, returns `pos_type(-1)` to indicate
+failure. Otherwise, returns `rdbuf()->pubseekoff(0, cur, out)`.
 ``` cpp
 basic_ostream<charT, traits>& seekp(pos_type pos);
 ```
+*Effects:* If `fail() != true`, executes
+`rdbuf()->pubseekpos(pos, ios_base::out)`. In case of failure, the
+function calls `setstate(failbit)` (which may throw
+`ios_base::failure`).
+*Returns:* `*this`.
 ``` cpp
 basic_ostream<charT, traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
 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`.
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
 these types as its interface to iostreams, since for flexibility it has
 been abstracted away from direct dependence on `ostream`. The second
+parameter is a reference to the base class subobject of type `ios_base`.
+It provides formatting specifications such as field width, and a locale
 from which to obtain other facets. If `failed` is `true` then does
 `setstate(badbit)`, which may throw an exception, and returns.
 *Returns:* `*this`.
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
+basic_ostream<charT, traits>&
+  operator<<(basic_ostream<charT, traits>& (*pf)(basic_ostream<charT, traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^34]
 ``` cpp
+basic_ostream<charT, traits>&
+  operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
+*Returns:* `*this`.[^35]
 ``` cpp
+basic_ostream<charT, traits>& operator<<(ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 *Returns:* `*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:
 `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);
+```
+*Effects:* Equivalent to:
+``` 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>
+  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, charT c);
 template<class charT, class traits>
+  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, char c);
 // specialization
 template<class traits>
+  basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, char c);
 // signed and unsigned
 template<class traits>
+  basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, signed char c);
 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>
+  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, const charT* s);
 template<class charT, class traits>
+  basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& out, const char* s);
 template<class traits>
+  basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, const char* s);
 template<class traits>
+  basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out, const signed char* s);
 template<class traits>
   basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>& out,
                                           const unsigned char* s);
 ```
 - `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
   `const char*`,
+- `char_traits<char>::length(s)` for the overload where the first
   argument is of type `basic_ostream<charT, traits>&` and the second is
   of type `const char*`,
 - `traits::length(reinterpret_cast<const char*>(s))` for the other two
   overloads.
 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.
 ``` cpp
 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);
 ```
 *Effects:* Behaves as an unformatted output function (as described
+above). After constructing a sentry object, obtains characters to insert
+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]])).
 ``` 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 `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);
 ```
 *Effects:* Calls `os.put(os.widen(’\n’))`, then `os.flush()`.
 *Returns:* `os`.
 ``` cpp
 template <class charT, class traits>
   basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
 ```
 *Effects:* Inserts a null character into the output sequence: calls
 `os.put(charT())`.
 *Returns:* `os`.
 ``` cpp
 template <class charT, class traits>
   basic_ostream<charT, traits>& flush(basic_ostream<charT, traits>& os);
 ```
 *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
 unspecified resetiosflags(ios_base::fmtflags mask);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
+`out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
+expression `in >> resetiosflags(mask)` behaves as if it called
+`f(in, mask)`, where the function `f` is defined as:[^39]
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
+`out << setiosflags(mask)` behaves as if it called `f(out, mask)`, or if
 `in` is an object of type `basic_istream<charT, traits>` then the
+expression `in >> setiosflags(mask)` behaves as if it called
 `f(in, mask)`, where the function `f` is defined as:
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
+`out << setbase(base)` behaves as if it called `f(out, base)`, or if
 `in` is an object of type `basic_istream<charT, traits>` then the
+expression `in >> setbase(base)` behaves as if it called `f(in, base)`,
 where the function `f` is defined as:
 ``` cpp
 void f(ios_base& str, int base) {
   // set basefield
       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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` and `c` has type `charT` then the
+expression `out << setfill(c)` behaves as if it called `f(out, c)`,
 where the function `f` is defined as:
 ``` cpp
 template<class charT, class traits>
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
+`out << setprecision(n)` behaves as if it called `f(out, n)`, or if `in`
 is an object of type `basic_istream<charT, traits>` then the expression
+`in >> setprecision(n)` behaves as if it called `f(in, n)`, where the
 function `f` is defined as:
 ``` cpp
 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);
 ```
 *Returns:* An object of unspecified type such that if `out` is an
 instance of `basic_ostream<charT, traits>` then the expression
+`out << setw(n)` behaves as if it called `f(out, n)`, or if `in` is an
 object of type `basic_istream<charT, traits>` then the expression
+`in >> setw(n)` behaves as if it called `f(in, n)`, where the function
 `f` is defined as:
 ``` cpp
 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
 *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:
 ``` cpp
 template <class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
+ using Iter     = istreambuf_iterator<charT, traits>;
+ using MoneyGet = money_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const MoneyGet& mg = use_facet<MoneyGet>(str.getloc());
   mg.get(Iter(str.rdbuf()), Iter(), intl, str, err, mon);
   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) {
+ using Iter     = ostreambuf_iterator<charT, traits>;
+ using MoneyPut = money_put<charT, Iter>;
   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:
 ``` cpp
 template <class charT, class traits>
 void f(basic_ios<charT, traits>& str, struct tm* tmb, const charT* fmt) {
+ using Iter    = istreambuf_iterator<charT, traits>;
+ using TimeGet = time_get<charT, Iter>;
   ios_base::iostate err = ios_base::goodbit;
   const TimeGet& tg = use_facet<TimeGet>(str.getloc());
   tg.get(Iter(str.rdbuf()), Iter(), str, err, tmb,
     fmt, fmt + traits::length(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);
 ```
 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:
 ``` cpp
 template <class charT, class traits>
 void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
+ using Iter    = ostreambuf_iterator<charT, traits>;
+ using TimePut = time_put<charT, Iter>;
   const TimePut& tp = use_facet<TimePut>(str.getloc());
   const Iter end = tp.put(Iter(str.rdbuf()), str, str.fill(), tmb,
     fmt, fmt + traits::length(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
+of quoted strings (for example, XML and CSV formats). Quoted
+manipulators are useful in ensuring that the content of a string with
+embedded spaces remains unchanged if inserted and then extracted via
+stream I/O. — *end note*]
 ``` cpp
 template <class charT>
   unspecified quoted(const charT* s, charT delim = charT('"'), charT escape = charT('\\'));
 template <class charT, class traits, class Allocator>
   unspecified quoted(const basic_string<charT, traits, Allocator>& s,
+  \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
+template <class charT, class traits>
+  unspecified quoted(basic_string_view<charT, traits> s,
+  \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 ```
 *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`.
 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,
+  \itcorr                   charT delim = charT('"'), charT escape = charT('\\'));
 ```
 *Returns:* An object of unspecified type such that:
 - 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
       characters from `in` and append them to `s`, except that if an
       `escape` is reached, ignore it and append the next character to
       `s`.
     - Discard the final `delim` character.
     - Restore the `skipws` flag to its original value.
+  - Otherwise, `in >> s`.
 - If `out` is an instance of `basic_ostream` with member types
   `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`.

Diff to HTML by rtfpessoa