Merge 2023-02 LWG Motion 8

P2609R3 Relaxing Ranges Just A Smidge

Author: tkoeppe

source/iterators.tex

@@ -84,9 +84,12 @@
   template<class In>
     concept indirectly_readable = @\seebelow@;                                        // freestanding
 
+  template<@\libconcept{indirectly_readable}@ T>
+    using @\exposidnc{indirect-value-t}@ = @\seebelow@;         // \expos
+
   template<@\libconcept{indirectly_readable}@ T>
     using @\libglobal{iter_common_reference_t}@ =                                                 // freestanding
-      common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;
+      common_reference_t<iter_reference_t<T>, @\exposid{indirect-value-t}@<T>>;
 
   // \ref{iterator.concept.writable}, concept \libconcept{indirectly_writable}
   template<class Out, class T>
@@ -2411,6 +2414,21 @@
 There are several concepts that group requirements of algorithms that
 take callable objects\iref{func.def} as arguments.
 
+\rSec3[indirectcallable.traits]{Indirect callable traits}
+
+\pnum
+To implement algorithms taking projections,
+it is necessary to determine the projected type of an iterator's value type.
+For the exposition-only alias template \exposid{indirect-value-t},
+\tcode{\exposid{indirect-value-t}<T>} denotes
+\begin{itemize}
+\item
+\tcode{invoke_result_t<Proj\&, \exposid{indirect-value-t}<I>>}
+if \tcode{T} names \tcode{projected<I, Proj>}, and
+\item
+\tcode{iter_value_t<T>\&} otherwise.
+\end{itemize}
+
 \rSec3[indirectcallable.indirectinvocable]{Indirect callables}
 
 \pnum
@@ -2423,59 +2441,59 @@
     concept @\deflibconcept{indirectly_unary_invocable}@ =
       @\libconcept{indirectly_readable}@<I> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{invocable}@<F&, iter_value_t<I>&> &&
+      @\libconcept{invocable}@<F&, @\exposid{indirect-value-t}@<I>> &&
       @\libconcept{invocable}@<F&, iter_reference_t<I>> &&
       @\libconcept{invocable}@<F&, iter_common_reference_t<I>> &&
       @\libconcept{common_reference_with}@<
-        invoke_result_t<F&, iter_value_t<I>&>,
+        invoke_result_t<F&, @\exposid{indirect-value-t}@<I>>,
         invoke_result_t<F&, iter_reference_t<I>>>;
 
   template<class F, class I>
     concept @\deflibconcept{indirectly_regular_unary_invocable}@ =
       @\libconcept{indirectly_readable}@<I> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{regular_invocable}@<F&, iter_value_t<I>&> &&
+      @\libconcept{regular_invocable}@<F&, @\exposid{indirect-value-t}@<I>> &&
       @\libconcept{regular_invocable}@<F&, iter_reference_t<I>> &&
       @\libconcept{regular_invocable}@<F&, iter_common_reference_t<I>> &&
       @\libconcept{common_reference_with}@<
-        invoke_result_t<F&, iter_value_t<I>&>,
+        invoke_result_t<F&, @\exposid{indirect-value-t}@<I>>,
         invoke_result_t<F&, iter_reference_t<I>>>;
 
   template<class F, class I>
     concept @\deflibconcept{indirect_unary_predicate}@ =
       @\libconcept{indirectly_readable}@<I> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{predicate}@<F&, iter_value_t<I>&> &&
+      @\libconcept{predicate}@<F&, @\exposid{indirect-value-t}@<I>> &&
       @\libconcept{predicate}@<F&, iter_reference_t<I>> &&
       @\libconcept{predicate}@<F&, iter_common_reference_t<I>>;
 
   template<class F, class I1, class I2>
     concept @\deflibconcept{indirect_binary_predicate}@ =
       @\libconcept{indirectly_readable}@<I1> && @\libconcept{indirectly_readable}@<I2> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{predicate}@<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      @\libconcept{predicate}@<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      @\libconcept{predicate}@<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
+      @\libconcept{predicate}@<F&, @\exposid{indirect-value-t}@<I1>, @\exposid{indirect-value-t}@<I2>> &&
+      @\libconcept{predicate}@<F&, @\exposid{indirect-value-t}@<I1>, iter_reference_t<I2>> &&
+      @\libconcept{predicate}@<F&, iter_reference_t<I1>, @\exposid{indirect-value-t}@<I2>> &&
       @\libconcept{predicate}@<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       @\libconcept{predicate}@<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 
   template<class F, class I1, class I2 = I1>
     concept @\deflibconcept{indirect_equivalence_relation}@ =
       @\libconcept{indirectly_readable}@<I1> && @\libconcept{indirectly_readable}@<I2> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{equivalence_relation}@<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      @\libconcept{equivalence_relation}@<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      @\libconcept{equivalence_relation}@<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
+      @\libconcept{equivalence_relation}@<F&, @\exposid{indirect-value-t}@<I1>, @\exposid{indirect-value-t}@<I2>> &&
+      @\libconcept{equivalence_relation}@<F&, @\exposid{indirect-value-t}@<I1>, iter_reference_t<I2>> &&
+      @\libconcept{equivalence_relation}@<F&, iter_reference_t<I1>, @\exposid{indirect-value-t}@<I2>&> &&
       @\libconcept{equivalence_relation}@<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       @\libconcept{equivalence_relation}@<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 
   template<class F, class I1, class I2 = I1>
     concept @\deflibconcept{indirect_strict_weak_order}@ =
       @\libconcept{indirectly_readable}@<I1> && @\libconcept{indirectly_readable}@<I2> &&
       @\libconcept{copy_constructible}@<F> &&
-      @\libconcept{strict_weak_order}@<F&, iter_value_t<I1>&, iter_value_t<I2>&> &&
-      @\libconcept{strict_weak_order}@<F&, iter_value_t<I1>&, iter_reference_t<I2>> &&
-      @\libconcept{strict_weak_order}@<F&, iter_reference_t<I1>, iter_value_t<I2>&> &&
+      @\libconcept{strict_weak_order}@<F&, @\exposid{indirect-value-t}@<I1>, @\exposid{indirect-value-t}@<I2>> &&
+      @\libconcept{strict_weak_order}@<F&, @\exposid{indirect-value-t}@<I1>, iter_reference_t<I2>> &&
+      @\libconcept{strict_weak_order}@<F&, iter_reference_t<I1>, @\exposid{indirect-value-t}@<I2>> &&
       @\libconcept{strict_weak_order}@<F&, iter_reference_t<I1>, iter_reference_t<I2>> &&
       @\libconcept{strict_weak_order}@<F&, iter_common_reference_t<I1>, iter_common_reference_t<I2>>;
 }

source/support.tex

@@ -682,7 +682,7 @@
 #define @\defnlibxname{cpp_lib_polymorphic_allocator}@             201902L // also in \libheader{memory_resource}
 #define @\defnlibxname{cpp_lib_print}@                             202207L // also in \libheader{print}, \libheader{ostream}
 #define @\defnlibxname{cpp_lib_quoted_string_io}@                  201304L // also in \libheader{iomanip}
-#define @\defnlibxname{cpp_lib_ranges}@                            202211L
+#define @\defnlibxname{cpp_lib_ranges}@                            202302L
   // also in \libheader{algorithm}, \libheader{functional}, \libheader{iterator}, \libheader{memory}, \libheader{ranges}
 #define @\defnlibxname{cpp_lib_ranges_as_const}@                   202207L // also in \libheader{ranges}
 #define @\defnlibxname{cpp_lib_ranges_as_rvalue}@                  202207L // also in \libheader{ranges}