[Bug libstdc++/109203] New: sort(zip(v1, v2)) fails to compile

[Bug libstdc++/109203] New: sort(zip(v1, v2)) fails to compile

[dvirtz at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

            Bug ID: 109203
           Summary: sort(zip(v1, v2)) fails to compile
           Product: gcc
           Version: 13.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: dvirtz at gmail dot com
  Target Milestone: ---

```
    std::vector<int> vi;
    std::vector<std::string> vs;
    ranges::sort(views::zip(vi, vs));
```

results in

```
/opt/compiler-explorer/gcc-trunk-20230319/include/c++/13.0.1/bits/ranges_algo.h:54:31:
error: no matching function for call to '__invoke(std::ranges::less&,
std::pair<int, std::__cxx11::basic_string<char> >&, std::pair<int&,
std::__cxx11::basic_string<char>&>)'
   54 |           return std::__invoke(__comp,
      |                  ~~~~~~~~~~~~~^~~~~~~~
   55 |                                std::__invoke(__proj,
std::forward<_TL>(__lhs)),
      |                               
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   56 |                                std::__invoke(__proj,
std::forward<_TR>(__rhs)));
      |                               
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

```

https://godbolt.org/z/j5aj34dxb

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[dvirtz at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #1 from Dvir Yitzchaki <dvirtz at gmail dot com> ---
it works when zipping more than 2 ranges

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Created attachment 54707
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=54707&action=edit
Full testcase

Next time don't just do code snippets but rather a full testcase in the
comment. And don't assume godbolt URL is enough.

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Note for this to work with LLVM's libc++, you need the following include file
added:
#include <string>

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #4 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Technically, that's needed for libstdc++ too, it just happens to work "by
accident" without it.

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2023-03-20
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW
                 CC|                            |ppalka at gcc dot gnu.org

--- Comment #5 from Patrick Palka <ppalka at gcc dot gnu.org> ---
This is https://wg21.link/lwg3865 which we don't yet implement (or P2165R4)

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[de34 at live dot cn]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

Jiang An <de34 at live dot cn> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |de34 at live dot cn

--- Comment #6 from Jiang An <de34 at live dot cn> ---
libstdc++ has (unfortunately?) implemented the tuple-or-pair strategy in P2321.
The strategy is dropped by P2165. It seems that if std::tuple is
unconditionally used, this issue will be resolved.

This issue will also be resolved once LWG3865 gets implemented.

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[ppalka at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

Patrick Palka <ppalka at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Assignee|unassigned at gcc dot gnu.org      |ppalka at gcc dot gnu.org
             Status|NEW                         |ASSIGNED

--- Comment #7 from Patrick Palka <ppalka at gcc dot gnu.org> ---
I can start working on implementing P2165.

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #8 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Thanks, Patrick. I have a patch for LWG 3865 too.

[Bug libstdc++/109203] sort(zip(v1, v2)) fails to compile

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109203

--- Comment #9 from GCC Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Patrick Palka <ppalka@gcc.gnu.org>:

https://gcc.gnu.org/g:65b4cba9d6a9ffe9b4d4bdff90727a7064cc0e3b

commit r14-8710-g65b4cba9d6a9ffe9b4d4bdff90727a7064cc0e3b
Author: Patrick Palka <ppalka@redhat.com>
Date:   Thu Feb 1 14:59:46 2024 -0500

    libstdc++: Implement P2165R4 changes to std::pair/tuple/etc [PR113309]

    This implements the C++23 paper P2165R4 Compatibility between tuple,
    pair and tuple-like objects, which builds upon many changes from the
    earlier C++23 paper P2321R2 zip.

    Some declarations had to be moved around so that they're visible from
    <bits/stl_pair.h> without introducing new includes and bloating the
    header.  In the end, the only new include is for <bits/utility.h> from
    <bits/stl_iterator.h>, for tuple_element_t.

            PR libstdc++/113309
            PR libstdc++/109203

    libstdc++-v3/ChangeLog:

            * include/bits/ranges_util.h (__detail::__pair_like): Don't
            define in C++23 mode.
            (__detail::__pair_like_convertible_from): Adjust as per P2165R4.
            (__detail::__is_subrange<subrange>): Moved from <ranges>.
            (__detail::__is_tuple_like_v<subrange>): Likewise.
            * include/bits/stl_iterator.h: Include <bits/utility.h> for
            C++23.
            (__different_from): Move to <concepts>.
            (__iter_key_t): Adjust for C++23 as per P2165R4.
            (__iter_val_t): Likewise.
            * include/bits/stl_pair.h (pair, array): Forward declare.
            (get): Forward declare all overloads relevant to P2165R4
            tuple-like constructors.
            (__is_tuple_v): Define for C++23.
            (__is_tuple_like_v): Define for C++23.
            (__tuple_like): Define for C++23 as per P2165R4.
            (__pair_like): Define for C++23 as per P2165R4.
            (__eligibile_tuple_like): Define for C++23.
            (__eligibile_pair_like): Define for C++23.
            (pair::_S_constructible_from_pair_like): Define for C++23.
            (pair::_S_convertible_from_pair_like): Define for C++23.
            (pair::_S_dangles_from_pair_like): Define for C++23.
            (pair::pair): Define overloads taking a tuple-like type for
            C++23 as per P2165R4.
            (pair::_S_assignable_from_tuple_like): Define for C++23.
            (pair::_S_const_assignable_from_tuple_like): Define for C++23.
            (pair::operator=): Define overloads taking a tuple-like type for
            C++23 as per P2165R4.
            * include/bits/utility.h (ranges::__detail::__is_subrange):
            Moved from <ranges>.
            * include/bits/version.def (tuple_like): Define for C++23.
            * include/bits/version.h: Regenerate.
            * include/std/concepts (__different_from): Moved from
            <bits/stl_iterator.h>.
            (ranges::__swap::__adl_swap): Clarify which __detail namespace.
            * include/std/map (__cpp_lib_tuple_like): Define C++23.
            * include/std/ranges (__detail::__is_subrange): Moved to
            <bits/utility.h>.
            (__detail::__is_subrange<subrange>): Moved to <bits/ranges_util.h>
            (__detail::__has_tuple_element): Adjust for C++23 as per P2165R4.
            (__detail::__tuple_or_pair): Remove as per P2165R4.  Replace all
            uses with plain tuple as per P2165R4.
            * include/std/tuple (__cpp_lib_tuple_like): Define for C++23.
            (__tuple_like_tag_t): Define for C++23.
            (__tuple_cmp): Forward declare for C++23.
            (_Tuple_impl::_Tuple_impl): Define overloads taking
            __tuple_like_tag_t and a tuple-like type for C++23.
            (_Tuple_impl::_M_assign): Likewise.
            (tuple::__constructible_from_tuple_like): Define for C++23.
            (tuple::__convertible_from_tuple_like): Define for C++23.
            (tuple::__dangles_from_tuple_like): Define for C++23.
            (tuple::tuple): Define overloads taking a tuple-like type for
            C++23 as per P2165R4.
            (tuple::__assignable_from_tuple_like): Define for C++23.
            (tuple::__const_assignable_from_tuple_like): Define for C++23.
            (tuple::operator=): Define overloads taking a tuple-like type
            for C++23 as per P2165R4.
            (tuple::__tuple_like_common_comparison_category): Define for C++23.
            (tuple::operator<=>): Define overload taking a tuple-like type
            for C++23 as per P2165R4.
            (array, get): Forward declarations moved to <bits/stl_pair.h>.
            (tuple_cat): Constrain with __tuple_like for C++23 as per P2165R4.
            (apply): Likewise.
            (make_from_tuple): Likewise.
            (__tuple_like_common_reference): Define for C++23.
            (basic_common_reference): Adjust as per P2165R4.
            (__tuple_like_common_type): Define for C++23.
            (common_type): Adjust as per P2165R4.
            * include/std/unordered_map (__cpp_lib_tuple_like): Define for
            C++23.
            * include/std/utility (__cpp_lib_tuple_like): Define for C++23.
            * testsuite/std/ranges/zip/1.cc (test01): Adjust to handle pair
            and 2-tuple interchangeably.
            (test05): New test.
            * testsuite/20_util/pair/p2165r4.cc: New test.
            * testsuite/20_util/tuple/p2165r4.cc: New test.

    Reviewed-by: Jonathan Wakely <jwakely@redhat.com>