fixup: paper transcription errors

Author: jensmaurer

source/containers.tex

@@ -945,6 +945,7 @@
 but specialized allocators can choose a different definition.
 \end{note}
 
+\pnum
 The following exposition-only concept is used in the definition of containers:
 \begin{codeblock}
 template<class R, class T>
@@ -1719,6 +1720,7 @@
 \tcode{\libconcept{assignable_from}<T\&, ranges::range_reference_t<R>>}
 is modeled.
 
+\pnum
 \expects
 \tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{X}
 from \tcode{*ranges::begin(rg)}.
@@ -1990,7 +1992,7 @@
 \pnum
 \expects
 \tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{X}
-from \tcode{ranges::begin(rg)}.
+from \tcode{*ranges::begin(rg)}.
 
 \pnum
 \effects
@@ -2072,7 +2074,10 @@
 \pnum
 \expects
 \tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{X}
-from \tcode{ranges::begin(rg)}.
+from \tcode{*ranges::begin(rg)}.
+For \tcode{vector},
+\tcode{T} is also
+\oldconcept{MoveInsertable} into \tcode{X}.
 
 \pnum
 \effects
@@ -2620,7 +2625,7 @@
 \range{i}{j} denotes a valid range,
 \item
 \tcode{rg} denotes a value of a type \tcode{R}
-that models \exposconcept{container-compatible-range<value_type>},
+that models \tcode{\exposconcept{container-compatible-range}<value_type>},
 \item
 \tcode{p} denotes a valid constant iterator to \tcode{a},
 \item
@@ -2925,7 +2930,7 @@
 
 \pnum
 \complexity
-same as \tcode{X(from_range, rg, c)}
+Same as \tcode{X(from_range, rg, c)}.
 \end{itemdescr}
 
 \indexlibraryctor{set}%
@@ -6642,7 +6647,7 @@
 
 \indexlibraryctor{deque}%
 \begin{itemdecl}
-template<@\libconcept{container-compatible-range}@<T> R>
+template<@\exposconcept{container-compatible-range}@<T> R>
   deque(from_range_t, R&& rg, const Allocator& = Allocator());
 \end{itemdecl}
 
@@ -7112,7 +7117,7 @@
 \indexlibraryctor{forward_list}%
 \begin{itemdecl}
 template<@\exposconcept{container-compatible-range}@<T> R>
-forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
+  forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -7301,7 +7306,7 @@
 \pnum
 \expects
 \tcode{position} is \tcode{before_begin()} or
-is a dereferenceable iterator in the range [begin(), end()).
+is a dereferenceable iterator in the range \range{begin()}{end()}.
 \tcode{rg} and \tcode{*this} do not overlap.
 
 \pnum
@@ -8008,7 +8013,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Constructs a list object with the elements of the range \tcode{rg}.
+Constructs a \tcode{list} object with the elements of the range \tcode{rg}.
 
 \pnum
 \complexity
@@ -8505,7 +8510,7 @@
 and, for an element type other than \tcode{bool},
 of a contiguous container\iref{container.requirements.general}.
 The exceptions are the
-\tcode{push_front}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
+\tcode{push_front}, \tcode{prepend_range}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
 provided. Descriptions are provided here only for operations on \tcode{vector}
 that are not described in one of these tables or for operations where there is
 additional semantic information.
@@ -8756,7 +8761,7 @@
 from the results of dereferencing successive iterators of \tcode{rg},
 where $N$ is \tcode{ranges::distance(rg)}.
 Performs no reallocations if \tcode{R} models
-ranges::\libconcept{forward_range} or ranges::\libconcept{sized_range};
+\tcode{ranges::\libconcept{forward_range}} or \tcode{ranges::\libconcept{sized_range}};
 otherwise, performs order $\log N$ reallocations and
 order $N$ calls to the copy or move constructor of \tcode{T}.
 \end{itemdescr}
@@ -10090,7 +10095,7 @@
       multimap(InputIterator first, InputIterator last,
                const Compare& comp = Compare(),
                const Allocator& = Allocator());
-    template<@\exposid{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       multimap(from_range_t, R&& rg,
                const Compare& comp = Compare(), const Allocator& = Allocator());
     multimap(const multimap& x);
@@ -10627,14 +10632,14 @@
 
 \indexlibraryctor{set}%
 \begin{itemdecl}
-template<@\exposid{container-compatible-range}@<value_type> R>
+template<@\exposconcept{container-compatible-range}@<value_type> R>
   set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \effects
-Constructs an empty set using the specified comparison object and allocator,
+Constructs an empty \tcode{set} using the specified comparison object and allocator,
 and inserts elements from the range \tcode{rg}.
 
 \pnum
@@ -10743,7 +10748,7 @@
     template<class InputIterator>
       multiset(InputIterator first, InputIterator last,
                const Compare& comp = Compare(), const Allocator& = Allocator());
-    template<@\exposid{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       multiset(from_range_t, R&& rg,
                const Compare& comp = Compare(), const Allocator& = Allocator());
     multiset(const multiset& x);
@@ -10799,7 +10804,7 @@
     iterator insert(const_iterator position, value_type&& x);
     template<class InputIterator>
       void insert(InputIterator first, InputIterator last);
-    template<@\exposid{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       void insert_range(R&& rg);
     void insert(initializer_list<value_type>);
 
@@ -11232,10 +11237,10 @@
       unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
                     const allocator_type& a)
         : unordered_map(f, l, n, hf, key_equal(), a) { }
-    template<@\libconcept{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { }
-    template<@\libconcept{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
         : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }
     unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
@@ -11275,7 +11280,7 @@
     iterator       insert(const_iterator hint, value_type&& obj);
     template<class P> iterator insert(const_iterator hint, P&& obj);
     template<class InputIterator> void insert(InputIterator first, InputIterator last);
-    template<@\libconcept{container-compatible-range}@<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       void insert_range(R&& rg);
     void insert(initializer_list<value_type>);
 
@@ -11414,7 +11419,7 @@
                        equal_to<@\placeholder{iter-key-type}@<InputIterator>>, Allocator>;
 
   template<ranges::\tcode{input_range} R, class Allocator>
-    unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
+    unordered_map(from_range_t, R&&, typename @\seebelow@::size_type, Allocator)
       -> unordered_map<@\exposid{range-key-type}@<R>, @\exposid{range-mapped-type}@<R>, hash<@\exposid{range-key-type}@<R>>,
                        equal_to<@\exposid{range-key-type}@<R>>, Allocator>;
 
@@ -12413,7 +12418,7 @@
       -> unordered_set<@\placeholder{iter-value-type}@<InputIterator>,
                        Hash, Pred, Allocator>;
 
-  template<ranges::input_range R,
+  template<ranges::@\libconcept{input_range}@ R,
            class Hash = hash<ranges::range_value_t<R>>,
            class Pred = equal_to<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
@@ -12633,7 +12638,7 @@
                          const hasher& hf = hasher(),
                          const key_equal& eql = key_equal(),
                          const allocator_type& a = allocator_type());
-    template<container-compatible-range<value_type> R>
+    template<@\exposconcept{container-compatible-range}@<value_type> R>
       unordered_multiset(from_range_t, R&& rg,
                          size_type n = @\seebelow@,
                          const hasher& hf = hasher(),
@@ -12786,7 +12791,7 @@
       -> unordered_multiset<@\placeholder{iter-value-type}@<InputIterator>,
                             Hash, Pred, Allocator>;
 
-  template<ranges::input_range R,
+  template<ranges::@\libconcept{input_range}@ R,
            class Hash = hash<ranges::range_value_t<R>>,
            class Pred = equal_to<ranges::range_value_t<R>>,
            class Allocator = allocator<ranges::range_value_t<R>>>
@@ -12824,7 +12829,7 @@
       -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
                             equal_to<ranges::range_value_t<R>>, Allocator>;
 
-  template<ranges::input_range R, class Hash, class Allocator>
+  template<ranges::@\libconcept{input_range}@ R, class Hash, class Allocator>
     unordered_multiset(from_range_t, R&&, typename @\seebelow@::size_type, Hash, Allocator)
       -> unordered_multiset<ranges::range_value_t<R>, Hash, equal_to<ranges::range_value_t<R>>,
                             Allocator>;
@@ -13102,6 +13107,7 @@
       queue(InputIterator first, InputIterator last, const Alloc&);
     template<@\exposconcept{container-compatible-range}@<T> R, class Alloc>
       queue(from_range_t, R&& rg, const Alloc&);
+
     [[nodiscard]] bool empty() const    { return c.empty(); }
     size_type         size()  const     { return c.size(); }
     reference         front()           { return c.front(); }
@@ -13301,7 +13307,7 @@
 \effects
 Equivalent to \tcode{c.append_range(std::forward<R>(rg))}
 if that is a valid expression,
-otherwise \tcode{ranges::copy(rg, back_inserter(c));}
+otherwise \tcode{ranges::copy(rg, back_inserter(c))}.
 \end{itemdescr}
 
 \rSec3[queue.ops]{Operators}
@@ -13803,7 +13809,7 @@
 
 \indexlibraryctor{priority_queue}%
 \begin{itemdecl}
-template<container-compatible-range<T> R, class Alloc>
+template<@\exposconcept{container-compatible-range}@<T> R, class Alloc>
   priority_queue(from_range_t, R&& rg, const Alloc& a);
 \end{itemdecl}
 
@@ -14164,7 +14170,7 @@
 \effects
 Equivalent to \tcode{c.append_range(std::forward<R>(rg))}
 if that is a valid expression,
-otherwise \tcode{ranges::copy(rg, back_inserter(c));}
+otherwise \tcode{ranges::copy(rg, back_inserter(c))}.
 \end{itemdescr}
 
 \rSec3[stack.ops]{Operators}

source/ranges.tex

@@ -139,6 +139,16 @@
   template<@\libconcept{range}@ R>
     using borrowed_subrange_t = @\seebelow@;
 
+  // \ref{range.utility.conv}, range conversions
+  template<class C, @\libconcept{input_range}@ R, class... Args> requires (!@\libconcept{view}@<C>)
+    constexpr C to(R&& r, Args&&... args);
+  template<template<class...> class C, @\libconcept{input_range}@ R, class... Args>
+    constexpr auto to(R&& r, Args&&... args) -> @\seebelow@;
+  template<class C, class... Args> requires (!@\libconcept{view}@<C>)
+    constexpr auto to(Args&&... args) -> @\seebelow@;
+  template<template<class...> class C, class... Args>
+    constexpr auto to(Args&&... args) -> @\seebelow@;
+
   // \ref{range.empty}, empty view
   template<class T>
     requires is_object_v<T>
@@ -330,15 +340,6 @@
     inline constexpr auto @\libmember{values}{views}@ = elements<1>;
   }
 
-  template<class C, @\libconcept{input_range}@ R, class... Args> requires (!@\libconcept{view}@<C>)
-    constexpr C to(R&& r, Args&&... args);
-  template<template<class...> class C, @\libconcept{input_range}@ R, class... Args>
-    constexpr auto to(R && r, Args&&... args) -> @\seebelow@;
-  template<class C, class... Args> requires (!@\exposid{view}@<C>)
-    constexpr auto to(Args&&... args) -> @\seebelow@;
-  template<template<class...> class C, class... Args>
-    constexpr auto to(Args&&... args) -> @\seebelow@;
-
   // \ref{range.zip}, zip view
   template<@\libconcept{input_range}@... Views>
     requires (@\libconcept{view}@<Views> && ...) && (sizeof...(Views) > 0)
@@ -2019,7 +2020,7 @@
 \begin{codeblock}
 string_view str = "the quick brown fox";
 auto words = views::split(str, ' ') | to<vector<string>>();
-// \tcode{words} is vector<string>{"the", "quick", "brown", "fox"}
+// \tcode{words} is \tcode{vector<string>\{"the", "quick", "brown", "fox"\}}
 \end{codeblock}
 \end{example}
 
@@ -2028,7 +2029,7 @@
 \begin{codeblock}
 template<class Container>
 constexpr bool @\exposid{reservable-container}@ =          // \expos
-  sized_range<Container> &&
+  @\libconcept{sized_range}@<Container> &&
   requires(Container& c, range_size_t<Container> n) {
     c.reserve(n);
     { c.capacity() } -> @\libconcept{same_as}@<decltype(n)>;
@@ -2042,16 +2043,16 @@
 template<class Container, class Ref>
 constexpr bool @\exposid{container-insertable}@ =          // \expos
   requires(Container& c, Ref&& ref) {
-      requires (requires { c.push_back(std::forward<Ref>(ref)); } ||
-                requires { c.insert(c.end(), std::forward<Ref>(ref)); });
+    requires (requires { c.push_back(std::forward<Ref>(ref)); } ||
+              requires { c.insert(c.end(), std::forward<Ref>(ref)); });
   };
 \end{codeblock}
 
 \pnum
 Let \exposid{container-inserter} be defined as follows:
 \begin{codeblock}
 template<typename Ref>
-auto @\exposid{container-inserter}@(C & c) {               // \expos
+auto @\exposid{container-inserter}@(C& c) {                // \expos
   if constexpr (requires { c.push_back(declval<Ref>()); })
     return back_inserter(c);
   else
@@ -2068,6 +2069,7 @@
 \end{itemdecl}
 
 \begin{itemdescr}
+\pnum
 \returns
 An object of type \tcode{C}
 constructed from the elements of \tcode{r} in the following manner:
@@ -2100,7 +2102,7 @@
 is \tcode{true}:
 \end{itemize}
 \begin{codeblock}
-C(ranges::begin(r), ranges::end(r), std::forward<Args>(args)...);
+C(ranges::begin(r), ranges::end(r), std::forward<Args>(args)...)
 \end{codeblock}
 \item
 Otherwise, if
@@ -2122,7 +2124,7 @@
 Otherwise,
 if \tcode{\libconcept{input_range}<range_reference_t<R>>} is \tcode{true}:
 \begin{codeblock}
-to<C>(r | views::transform([](auto &&elem) {
+to<C>(r | views::transform([](auto&& elem) {
   return to<range_value_t<C>>(std::forward<decltype(elem)>(elem));
 }), std::forward<Args>(args)...);
 \end{codeblock}
@@ -2142,7 +2144,7 @@
 \pnum
 Let \exposid{input-iterator} be an exposition-only type:
 \begin{codeblock}
-struct @\exposid{input-iterator}@ {                        //\expos
+struct @\exposid{input-iterator}@ {                        // \expos
   using iterator_category = input_iterator_tag;
   using value_type = range_value_t<R>;
   using difference_type = ptrdiff_t;
@@ -2183,7 +2185,7 @@
 \tcode{to<decltype(\placeholder{DEDUCE_EXPR})>(std::forward<R>(r), std::forward<Args>(args)...)}.
 \end{itemdescr}
 
-\rSec3[range.utility.conv.adapters]{\tcode{ranges::to} adaptors}
+\rSec3[range.utility.conv.adaptors]{\tcode{ranges::to} adaptors}
 
 \indexlibrarymember{to}{ranges}%
 \begin{itemdecl}

source/strings.tex

@@ -907,11 +907,11 @@
     constexpr basic_string& append(size_type n, charT c);
     template<class InputIterator>
       constexpr basic_string& append(InputIterator first, InputIterator last);
+    template<@\exposconcept{container-compatible-range}@<charT> R>
+      constexpr basic_string& append_range(R&& rg);
     constexpr basic_string& append(initializer_list<charT>);
 
     constexpr void push_back(charT c);
-    template<@\exposconcept{container-compatible-range}@<charT> R>
-      constexpr basic_string& append_range(R&& rg);
 
     constexpr basic_string& assign(const basic_string& str);
     constexpr basic_string& assign(basic_string&& str)

source/support.tex

@@ -602,7 +602,8 @@
 #define @\defnlibxname{cpp_lib_constexpr_utility}@                 201811L // also in \libheader{utility}
 #define @\defnlibxname{cpp_lib_constexpr_vector}@                  201907L // also in \libheader{vector}
 #define @\defnlibxname{cpp_lib_containers_ranges}@                 202202L
-  // also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set}, \libheader{deque}, \libheader{queue}, \libheader{priority_queue}, \libheader{stack}, \libheader{string}
+  // also in \libheader{vector}, \libheader{list}, \libheader{forward_list}, \libheader{map}, \libheader{set}, \libheader{unordered_map}, \libheader{unordered_set},
+  // \libheader{deque}, \libheader{queue}, \libheader{priority_queue}, \libheader{stack}, \libheader{string}
 #define @\defnlibxname{cpp_lib_coroutine}@                         201902L // also in \libheader{coroutine}
 #define @\defnlibxname{cpp_lib_destroying_delete}@                 201806L // also in \libheader{new}
 #define @\defnlibxname{cpp_lib_enable_shared_from_this}@           201603L // also in \libheader{memory}