This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of New status.

4074. compatible-joinable-ranges is underconstrained

Section: 26.7.15.2 [range.join.with.view] Status: New Submitter: Hewill Kang Opened: 2024-04-21 Last modified: 2024-04-27

Priority: Not Prioritized

View other active issues in [range.join.with.view].

View all other issues in [range.join.with.view].

View all issues with New status.

Discussion:

join_with_view requires the value type, reference and rvalue reference of the inner range and pattern range to share common (reference) types through compatible-joinable-ranges.

However, unlike what concat_view and generator do, this concept only requires that these three types be valid and does not further check the relationship between them to be compatible with the indirectly_readable requirement for input_iterator. This results in a validly-constructed join_with_view that may not model input_range, which seems unintended.

The proposed resolution aliases compatible-joinable-ranges to concatable i.e. specialization for two ranges to fully constrain, and I believe this could also be a better fit for LWG 3971.

Previous resolution [SUPERSEDED]:

This wording is relative to N4981.

1. Modify 26.7.15.2 [range.join.with.view] as indicated:

   namespace std::ranges {
     template<class R, class P>
       concept compatible-joinable-ranges = concatable<R, P>;  // exposition only
           common_with<range_value_t<R>, range_value_t<P>> &&
           common_reference_with<range_reference_t<R>, range_reference_t<P>> &&
           common_reference_with<range_rvalue_reference_t<R>, range_rvalue_reference_t<P>>;
     
     […]
   }
   

[2024-04-24; Hewill Kang provides improved wording]

Proposed resolution:

This wording is relative to N4981.

1. Modify 26.2 [ranges.syn] as indicated:

   #include <compare>              // see 17.11.1 [compare.syn]
   #include <initializer_list>     // see 17.10.2 [initializer.list.syn]
   #include <iterator>             // see 25.2 [iterator.synopsis]
   
   namespace std::ranges {
     […]
     // 26.7.15 [range.join.with], join with view
     template<class R, class P>
       concept compatible-joinable-ranges = see below; // exposition only
   
     template<input_range V, forward_range Pattern>
       requires view<V> && input_range<range_reference_t<V>>
             && view<Pattern>
             && compatible-joinable-ranges<range_reference_t<V>, Pattern>
             see below
     class join_with_view;                                                             // freestanding
     […]
   }
   

2. Modify 26.7.15.2 [range.join.with.view] as indicated:

   namespace std::ranges {
     template<class R, class P>
       concept compatible-joinable-ranges =            // exposition only
           common_with<range_value_t<R>, range_value_t<P>> &&
           common_reference_with<range_reference_t<R>, range_reference_t<P>> &&
           common_reference_with<range_rvalue_reference_t<R>, range_rvalue_reference_t<P>>;
     
     […]
   
     template<input_range V, forward_range Pattern>
       requires view<V> && input_range<range_reference_t<V>>
             && view<Pattern>
             && compatible-joinable-rangesconcatable<range_reference_t<V>, Pattern>
     class join_with_view : public view_interface<join_with_view<V, Pattern>> {
       […]
       constexpr auto begin() const
         requires forward_range<const V> &&
                  forward_range<const Pattern> &&
                  is_reference_v<range_reference_t<const V>> &&
                  input_range<range_reference_t<const V>> &&
                  concatable<range_reference_t<const V>, const Pattern> {
         return iterator<true>{*this, ranges::begin(base_)};
       }
       […]
       constexpr auto end() const
         requires forward_range<const V> && forward_range<const Pattern> &&
                  is_reference_v<range_reference_t<const V>> &&
                  input_range<range_reference_t<const V>> &&
                  concatable<range_reference_t<const V>, const Pattern> {
         […]
       }
     };
   }
   

3. Modify 26.7.15.3 [range.join.with.iterator] as indicated:

   namespace std::ranges {
     template<input_range V, forward_range Pattern>
       requires view<V> && input_range<range_reference_t<V>>
             && view<Pattern> && compatible-joinable-rangesconcatable<range_reference_t<V>, Pattern>
     template<bool Const>
     class join_with_view<V, Pattern>::iterator {
       […]
     };
   }
   

4. Modify 26.7.15.4 [range.join.with.sentinel] as indicated:

   namespace std::ranges {
     template<input_range V, forward_range Pattern>
       requires view<V> && input_range<range_reference_t<V>>
             && view<Pattern> && compatible-joinable-rangesconcatable<range_reference_t<V>, Pattern>
     template<bool Const>
     class join_with_view<V, Pattern>::sentinel {
       […]
     };
   }