[Motions 2025 11 lwg 2] C++ Standard Library Immediate Issues

source/algorithms.tex

@@ -233,7 +233,9 @@
 \end{codeblock}
 For each iterator \tcode{i} and sentinel \tcode{s}
 produced from a range \tcode{r},
-the semantics of \tcode{s - i} has the same type, value, and value category
+the semantics of \tcode{s - i}
+are the same as those of an expression that
+has the same type, value, and value category
 as \tcode{ranges::distance(i, s)}.
 \begin{note}
 The implementation can use \tcode{ranges::distance(r)}
@@ -379,7 +381,9 @@
 \tcode{BinaryOperation1},
 \tcode{BinaryOperation2},
 \tcode{BinaryDivideOp}, or
-constrained by a concept that subsumes \libconcept{regular_invocable}
+constrained by a concept
+whose semantic requirements include
+that the type models \libconcept{regular_invocable}
 and the operators used by the analogous overloads to these parallel algorithms
 that are formed by an invocation
 with the specified default predicate or operation (where applicable)
@@ -2097,27 +2101,28 @@
 
   namespace ranges {
     template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,
-             class T1 = projected_value_t<I, Proj>, class T2 = T1>
+             class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<I>>
       requires @\libconcept{indirectly_writable}@<I, const T2&> &&
                @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T1*>
       constexpr I
         replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
     template<@\libconcept{input_range}@ R, class Proj = identity,
-             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = range_value_t<R>>
       requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T2&> &&
                @\libconcept{indirect_binary_predicate}@<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T1*>
       constexpr borrowed_iterator_t<R>
         replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
 
     template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,
-             class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = T1>
+             class Proj = identity,
+             class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<I>>
       requires @\libconcept{indirectly_writable}@<I, const T2&> &&
                @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T1*>
       I replace(Ep&& exec, I first, S last,
                 const T1& old_value, const T2& new_value, Proj proj = {});  // freestanding-deleted
     template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,
-             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+             class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = range_value_t<R>>
       requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T2&> &&
                @\libconcept{indirect_binary_predicate}@<ranges::equal_to,
                                          projected<iterator_t<R>, Proj>, const T1*>
@@ -2126,24 +2131,24 @@
                 Proj proj = {});                                            // freestanding-deleted
 
     template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,
-             class T = projected_value_t<I, Proj>,
+             class T = iter_value_t<I>,
              @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>
       requires @\libconcept{indirectly_writable}@<I, const T&>
       constexpr I replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-    template<@\libconcept{input_range}@ R, class Proj = identity, class T = projected_value_t<I, Proj>,
+    template<@\libconcept{input_range}@ R, class Proj = identity, class T = range_value_t<R>,
              @\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>
       requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T&>
       constexpr borrowed_iterator_t<R>
         replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
 
     template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,
-             class Proj = identity, class T = projected_value_t<I, Proj>,
+             class Proj = identity, class T = iter_value_t<I>,
              @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>
       requires @\libconcept{indirectly_writable}@<I, const T&>
       I replace_if(Ep&& exec, I first, S last, Pred pred,
                    const T& new_value, Proj proj = {});         // freestanding-deleted
     template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,
-             class T = projected_value_t<iterator_t<R>, Proj>,
+             class T = range_value_t<R>,
              @\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>
       requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T&>
       borrowed_iterator_t<R>
@@ -7152,26 +7157,26 @@
                   Predicate pred, const T& new_value);
 
 template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,
-         class T1 = projected_value_t<I, Proj>, class T2 = T1>
+         class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<I>>
   requires @\libconcept{indirectly_writable}@<I, const T2&> &&
            @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T1*>
   constexpr I
     ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {});
 template<@\libconcept{input_range}@ R, class Proj = identity,
-         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = range_value_t<R>>
   requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T2&> &&
            @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
   constexpr borrowed_iterator_t<R>
     ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {});
 
 template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,
-         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = T1>
+         class Proj = identity, class T1 = projected_value_t<I, Proj>, class T2 = iter_value_t<I>>
   requires @\libconcept{indirectly_writable}@<I, const T2&> &&
            @\libconcept{indirect_binary_predicate}@<ranges::equal_to, projected<I, Proj>, const T1*>
   I ranges::replace(Ep&& exec, I first, S last,
                     const T1& old_value, const T2& new_value, Proj proj = {});
 template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,
-         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = T1>
+         class T1 = projected_value_t<iterator_t<R>, Proj>, class T2 = range_value_t<R>>
   requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T2&> &&
             @\libconcept{indirect_binary_predicate}@<ranges::equal_to,
                                       projected<iterator_t<R>, Proj>, const T1*>
@@ -7180,24 +7185,24 @@
                     Proj proj = {});
 
 template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, class Proj = identity,
-         class T = projected_value_t<I, Proj>,
+         class T = iter_value_t<I>,
          @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>
   requires @\libconcept{indirectly_writable}@<I, const T&>
   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
-template<@\libconcept{input_range}@ R, class Proj = identity, class T = projected_value_t<iterator_t<R>, Proj>,
+template<@\libconcept{input_range}@ R, class Proj = identity, class T = range_value_t<R>,
          @\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>
   requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T&>
   constexpr borrowed_iterator_t<R>
     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
 
 template<@\exposconcept{execution-policy}@ Ep, @\libconcept{random_access_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S,
-         class Proj = identity, class T = projected_value_t<I, Proj>,
+         class Proj = identity, class T = iter_value_t<I>,
          @\libconcept{indirect_unary_predicate}@<projected<I, Proj>> Pred>
   requires @\libconcept{indirectly_writable}@<I, const T&>
   I ranges::replace_if(Ep&& exec, I first, S last, Pred pred,
                        const T& new_value, Proj proj = {});
 template<@\exposconcept{execution-policy}@ Ep, @\exposconcept{sized-random-access-range}@ R, class Proj = identity,
-         class T = projected_value_t<iterator_t<R>, Proj>,
+         class T = range_value_t<R>,
          @\libconcept{indirect_unary_predicate}@<projected<iterator_t<R>, Proj>> Pred>
   requires @\libconcept{indirectly_writable}@<iterator_t<R>, const T&>
   borrowed_iterator_t<R>
@@ -8261,7 +8266,8 @@
 \effects
 Equivalent to:
 \begin{codeblock}
-return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r));
+return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle,
+                      ranges::begin(r) + ranges::distance(r));
 \end{codeblock}
 \end{itemdescr}
 
@@ -8386,8 +8392,10 @@
 \effects
 Equivalent to:
 \begin{codeblock}
-return ranges::rotate_copy(std::forward<Ep>(exec), ranges::begin(r), middle, ranges::end(r),
-                           ranges::begin(result_r), ranges::end(result_r));
+return ranges::rotate_copy(std::forward<Ep>(exec), ranges::begin(r), middle,
+                           ranges::begin(r) + ranges::distance(r),
+                           ranges::begin(result_r),
+                           ranges::begin(result_r) + ranges::distance(result_r));
 \end{codeblock}
 \end{itemdescr}
 
@@ -9007,7 +9015,8 @@
 Equivalent to:
 \begin{codeblock}
 return ranges::partial_sort(std::forward<Ep>(exec), ranges::begin(r), middle,
-                            ranges::end(r), comp, proj);
+                            ranges::begin(r) + ranges::distance(r),
+                            comp, proj);
 \end{codeblock}
 \end{itemdescr}
 
@@ -9391,7 +9400,8 @@
 \effects
 Equivalent to:
 \begin{codeblock}
-return ranges::nth_element(std::forward<Ep>(exec), ranges::begin(r), nth, ranges::end(r),
+return ranges::nth_element(std::forward<Ep>(exec), ranges::begin(r), nth,
+                           ranges::begin(r) + ranges::distance(r),
                            comp, proj);
 \end{codeblock}
 \end{itemdescr}
@@ -9960,14 +9970,14 @@
 
 \pnum
 \returns
-Let \tcode{o1} be the iterator past the last copied element
-in the output range \range{out_true}{last_true},
-and \tcode{o2} be the iterator past the last copied element
-in the output range \range{out_false}{last_false}.
+Let \tcode{$Q$} be the number of elements copied
+into the output range \range{out_true}{last_true},
+and \tcode{$V$} be the number of elements copied
+into the output range \range{out_false}{last_false}.
 Returns:
 \begin{itemize}
-\item \tcode{\{o1, o2\}} for the overloads in namespace \tcode{std}.
-\item \tcode{\{first + $N$, o1, o2\}} for the overloads in namespace \tcode{ranges}.
+\item \tcode{\{out_true + $Q$, out_false + $V$\}} for the overloads in namespace \tcode{std}.
+\item \tcode{\{first + $N$, out_true + $Q$, out_false + $V$\}} for the overloads in namespace \tcode{ranges}.
 \end{itemize}
 
 \pnum
@@ -10097,12 +10107,12 @@
   \tcode{proj2} be \tcode{identity\{\}},
   for the overloads with no parameters by those names;
 \item
-  $E(\tcode{e1}, \tcode{e1})$ be \tcode{bool(invoke(comp, invoke(proj2, e2), invoke(proj1, e1)))};
+  $E$ be \tcode{bool(invoke(comp, invoke(proj2, e2), invoke(proj1, e1)))};
 \item
   $K$ be the smallest integer in \range{0}{last1 - first1}
   such that for the element \tcode{e1} in the position \tcode{first1 + $K$}
   there are at least $N - K$ elements \tcode{e2}
-  in \range{first2}{last2} for which $E(\tcode{e1}, \tcode{e1})$ holds,
+  in \range{first2}{last2} for which $E$ holds,
   and be equal to \tcode{last1 - first1}
   if no such integer exists.
   \begin{note}
@@ -10127,7 +10137,7 @@
 If \tcode{e1} is an element of \range{first1}{last1} and
 \tcode{e2} of \range{first2}{last2},
 \tcode{e2} is copied into the output range before \tcode{e1}
-if and only if $E(\tcode{e1}, \tcode{e1})$ is \tcode{true}.
+if and only if $E$ is \tcode{true}.
 
 \pnum
 \returns
@@ -10264,7 +10274,8 @@
 Equivalent to:
 \begin{codeblock}
 return ranges::inplace_merge(std::forward<Ep>(exec), ranges::begin(r), middle,
-                             ranges::end(r), comp, proj);
+                             ranges::begin(r) + ranges::distance(r),
+                             comp, proj);
 \end{codeblock}
 \end{itemdescr}
 
@@ -13541,7 +13552,7 @@
   }
 
 template<class I>
-  decltype(auto) @\exposid{deref-move}@(I& it) {
+  constexpr decltype(auto) @\exposid{deref-move}@(I& it) {
     if constexpr (is_lvalue_reference_v<decltype(*it)>)
       return std::move(*it);
     else