[Bug libstdc++/113309] New: [C++23] Implement P2165R4, Compatibility between tuple and tuple-like objects

[Bug libstdc++/113309] New: [C++23] Implement P2165R4, Compatibility between tuple and tuple-like objects

[redi at gcc dot gnu.org]

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

            Bug ID: 113309
           Summary: [C++23] Implement P2165R4, Compatibility between tuple
                    and tuple-like objects
           Product: gcc
           Version: unknown
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: redi at gcc dot gnu.org
  Target Milestone: ---

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2165r4.pdf

[Bug libstdc++/113309] [C++23] Implement P2165R4, Compatibility between tuple and tuple-like objects

[redi at gcc dot gnu.org]

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

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
     Ever confirmed|0                           |1
           Assignee|unassigned at gcc dot gnu.org      |ppalka at gcc dot gnu.org
   Last reconfirmed|                            |2024-01-24
             Status|UNCONFIRMED                 |ASSIGNED

[Bug libstdc++/113309] [C++23] Implement P2165R4, Compatibility between tuple and tuple-like objects

[cvs-commit at gcc dot gnu.org]

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

--- Comment #1 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>

[Bug libstdc++/113309] [C++23] Implement P2165R4, Compatibility between tuple and tuple-like objects

[ppalka at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
   Target Milestone|---                         |14.0
         Resolution|---                         |FIXED

--- Comment #2 from Patrick Palka <ppalka at gcc dot gnu.org> ---
Implemented for GCC 14.