On Tue, 16 Sep 2025, Jonathan Wakely wrote:
> The std::tuple_cat function has to determine a std::tuple return type
> from zero or more tuple-like arguments. This uses the __make_tuple class
> template to transform a tuple-like type into a std::tuple, and the
> __combine_tuples class template to combine zero or more std::tuple types
> into a single std::tuple type.
>
> This change optimizes the __make_tuple class template to use an
> _Index_tuple and pack expansion instead of recursive instantiation, and
> optimizes __combine_tuples to use fewer levels of recursion.
>
> For ranges::adjacent_view's __detail::__repeated_tuple helper we can
> just use the __make_tuple class template directly, instead of doing
> overload resolution on std::tuple_cat to get its return type.
>
> libstdc++-v3/ChangeLog:
>
> * include/std/ranges (__detail::__repeated_tuple): Use
> __make_tuple helper alias directly, instead of doing overload
> resolution on std::tuple_cat.
> * include/std/tuple (__make_tuple_impl): Remove.
> (__do_make_tuple): Replace recursion with _Index_tuple and pack
> expansion.
> (__make_tuple): Adjust to new __do_make_tuple definition.
> (__combine_tuples<tuple<T1s...>, tuple<T2s...>, Rem...>): Replace
> with a partial specialization for exactly two tuples and a
> partial specialization for three or more tuples.
Nice! LGTM
> ---
>
> Tested powerpc64le-linux.
>
> libstdc++-v3/include/std/ranges | 2 +-
> libstdc++-v3/include/std/tuple | 51 ++++++++++++++++-----------------
> 2 files changed, 26 insertions(+), 27 deletions(-)
>
> diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> index f493da56203b..6c64f4c36213 100644
> --- a/libstdc++-v3/include/std/ranges
> +++ b/libstdc++-v3/include/std/ranges
> @@ -5383,7 +5383,7 @@ namespace views::__adaptor
> {
> // Yields tuple<_Tp, ..., _Tp> with _Nm elements.
> template<typename _Tp, size_t _Nm>
> - using __repeated_tuple =
> decltype(std::tuple_cat(std::declval<array<_Tp, _Nm>>()));
> + using __repeated_tuple = typename __make_tuple<array<_Tp,
> _Nm>>::__type;
>
> // For a functor F that is callable with N arguments, the expression
> // declval<__unarize<F, N>>(x) is equivalent to declval<F>(x, ..., x).
> diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
> index 2e6499eab22d..0ca616f1b4fb 100644
> --- a/libstdc++-v3/include/std/tuple
> +++ b/libstdc++-v3/include/std/tuple
> @@ -2681,54 +2681,53 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
>
> /// @cond undocumented
> - template<size_t, typename, typename, size_t>
> - struct __make_tuple_impl;
> + template<typename _Tuple, typename _Idx_tuple>
> + struct __do_make_tuple;
>
> - template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
> - struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
> - : __make_tuple_impl<_Idx + 1,
> - tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
> - _Tuple, _Nm>
> - { };
> -
> - template<size_t _Nm, typename _Tuple, typename... _Tp>
> - struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
> + template<typename _Tuple, size_t... _Idx>
> + struct __do_make_tuple<_Tuple, _Index_tuple<_Idx...>>
> {
> - typedef tuple<_Tp...> __type;
> + using __type = tuple<__tuple_element_t<_Idx, _Tuple>...>;
> };
>
> - template<typename _Tuple>
> - struct __do_make_tuple
> - : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
> - { };
> -
> // Returns the std::tuple equivalent of a tuple-like type.
> - template<typename _Tuple>
> + template<typename _Tuple,
> + typename _Tup = __remove_cvref_t<_Tuple>,
> + typename _Indices = _Build_index_tuple<tuple_size<_Tup>::value>>
> struct __make_tuple
> - : public __do_make_tuple<__remove_cvref_t<_Tuple>>
> + : __do_make_tuple<_Tup, typename _Indices::__type>
> { };
>
> - // Combines several std::tuple's into a single one.
> + // Combines several std::tuple types into a single one.
> template<typename...>
> struct __combine_tuples;
>
> template<>
> struct __combine_tuples<>
> {
> - typedef tuple<> __type;
> + using __type = tuple<>;
> };
>
> template<typename... _Ts>
> struct __combine_tuples<tuple<_Ts...>>
> {
> - typedef tuple<_Ts...> __type;
> + using __type = tuple<_Ts...>;
> };
>
> - template<typename... _T1s, typename... _T2s, typename... _Rem>
> - struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
> + template<typename... _T1s, typename... _T2s>
> + struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>>
> {
> - typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
> - _Rem...>::__type __type;
> + using __type = tuple<_T1s..., _T2s...>;
> + };
> +
> + template<typename... _T1s, typename... _T2s, typename... _T3s,
> + typename... _Rem>
> + struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, tuple<_T3s...>,
> + _Rem...>
> + {
> + using _First = tuple<_T1s..., _T2s..., _T3s...>;
> + using _Second = typename __combine_tuples<_Rem...>::__type;
> + using __type = typename __combine_tuples<_First, _Second>::__type;
> };
>
> // Computes the result type of tuple_cat given a set of tuple-like types.
> --
> 2.51.0
>
>
