libstdc++-v3/include/std/tuple

   1 // <tuple> -*- C++ -*-
   2
   3 // Copyright (C) 2007-2022 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/tuple
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 #ifndef _GLIBCXX_TUPLE
  30 #define _GLIBCXX_TUPLE 1
  31
  32 #pragma GCC system_header
  33
  34 #if __cplusplus < 201103L
  35 # include <bits/c++0x_warning.h>
  36 #else
  37
  38 #include <bits/stl_pair.h>              // for std::pair
  39 #include <bits/uses_allocator.h>        // for std::allocator_arg_t
  40 #include <bits/utility.h>               // for std::get, std::tuple_size etc.
  41 #include <bits/invoke.h>                // for std::__invoke
  42 #if __cplusplus > 201703L
  43 # include <compare>
  44 # define __cpp_lib_constexpr_tuple 201811L
  45 #endif
  46
  47 namespace std _GLIBCXX_VISIBILITY(default)
  48 {
  49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  50
  51   /**
  52    *  @addtogroup utilities
  53    *  @{
  54    */
  55
  56   template<typename... _Elements>
  57     class tuple;
  58
  59   template<typename _Tp>
  60     struct __is_empty_non_tuple : is_empty<_Tp> { };
  61
  62   // Using EBO for elements that are tuples causes ambiguous base errors.
  63   template<typename _El0, typename... _El>
  64     struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
  65
  66   // Use the Empty Base-class Optimization for empty, non-final types.
  67   template<typename _Tp>
  68     using __empty_not_final
  69     = __conditional_t<__is_final(_Tp), false_type,
  70                       __is_empty_non_tuple<_Tp>>;
  71
  72   template<size_t _Idx, typename _Head,
  73            bool = __empty_not_final<_Head>::value>
  74     struct _Head_base;
  75
  76 #if __has_cpp_attribute(__no_unique_address__)
  77   template<size_t _Idx, typename _Head>
  78     struct _Head_base<_Idx, _Head, true>
  79     {
  80       constexpr _Head_base()
  81       : _M_head_impl() { }
  82
  83       constexpr _Head_base(const _Head& __h)
  84       : _M_head_impl(__h) { }
  85
  86       constexpr _Head_base(const _Head_base&) = default;
  87       constexpr _Head_base(_Head_base&&) = default;
  88
  89       template<typename _UHead>
  90         constexpr _Head_base(_UHead&& __h)
  91         : _M_head_impl(std::forward<_UHead>(__h)) { }
  92
  93       _GLIBCXX20_CONSTEXPR
  94       _Head_base(allocator_arg_t, __uses_alloc0)
  95       : _M_head_impl() { }
  96
  97       template<typename _Alloc>
  98         _GLIBCXX20_CONSTEXPR
  99         _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 100         : _M_head_impl(allocator_arg, *__a._M_a) { }
 101
 102       template<typename _Alloc>
 103         _GLIBCXX20_CONSTEXPR
 104         _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 105         : _M_head_impl(*__a._M_a) { }
 106
 107       template<typename _UHead>
 108         _GLIBCXX20_CONSTEXPR
 109         _Head_base(__uses_alloc0, _UHead&& __uhead)
 110         : _M_head_impl(std::forward<_UHead>(__uhead)) { }
 111
 112       template<typename _Alloc, typename _UHead>
 113         _GLIBCXX20_CONSTEXPR
 114         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 115         : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 116         { }
 117
 118       template<typename _Alloc, typename _UHead>
 119         _GLIBCXX20_CONSTEXPR
 120         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 121         : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
 122
 123       static constexpr _Head&
 124       _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
 125
 126       static constexpr const _Head&
 127       _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
 128
 129       [[__no_unique_address__]] _Head _M_head_impl;
 130     };
 131 #else
 132   template<size_t _Idx, typename _Head>
 133     struct _Head_base<_Idx, _Head, true>
 134     : public _Head
 135     {
 136       constexpr _Head_base()
 137       : _Head() { }
 138
 139       constexpr _Head_base(const _Head& __h)
 140       : _Head(__h) { }
 141
 142       constexpr _Head_base(const _Head_base&) = default;
 143       constexpr _Head_base(_Head_base&&) = default;
 144
 145       template<typename _UHead>
 146         constexpr _Head_base(_UHead&& __h)
 147         : _Head(std::forward<_UHead>(__h)) { }
 148
 149       _GLIBCXX20_CONSTEXPR
 150       _Head_base(allocator_arg_t, __uses_alloc0)
 151       : _Head() { }
 152
 153       template<typename _Alloc>
 154         _GLIBCXX20_CONSTEXPR
 155         _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 156         : _Head(allocator_arg, *__a._M_a) { }
 157
 158       template<typename _Alloc>
 159         _GLIBCXX20_CONSTEXPR
 160         _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 161         : _Head(*__a._M_a) { }
 162
 163       template<typename _UHead>
 164         _GLIBCXX20_CONSTEXPR
 165         _Head_base(__uses_alloc0, _UHead&& __uhead)
 166         : _Head(std::forward<_UHead>(__uhead)) { }
 167
 168       template<typename _Alloc, typename _UHead>
 169         _GLIBCXX20_CONSTEXPR
 170         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 171         : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
 172
 173       template<typename _Alloc, typename _UHead>
 174         _GLIBCXX20_CONSTEXPR
 175         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 176         : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
 177
 178       static constexpr _Head&
 179       _M_head(_Head_base& __b) noexcept { return __b; }
 180
 181       static constexpr const _Head&
 182       _M_head(const _Head_base& __b) noexcept { return __b; }
 183     };
 184 #endif
 185
 186   template<size_t _Idx, typename _Head>
 187     struct _Head_base<_Idx, _Head, false>
 188     {
 189       constexpr _Head_base()
 190       : _M_head_impl() { }
 191
 192       constexpr _Head_base(const _Head& __h)
 193       : _M_head_impl(__h) { }
 194
 195       constexpr _Head_base(const _Head_base&) = default;
 196       constexpr _Head_base(_Head_base&&) = default;
 197
 198       template<typename _UHead>
 199         constexpr _Head_base(_UHead&& __h)
 200         : _M_head_impl(std::forward<_UHead>(__h)) { }
 201
 202       _GLIBCXX20_CONSTEXPR
 203       _Head_base(allocator_arg_t, __uses_alloc0)
 204       : _M_head_impl() { }
 205
 206       template<typename _Alloc>
 207         _GLIBCXX20_CONSTEXPR
 208         _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 209         : _M_head_impl(allocator_arg, *__a._M_a) { }
 210
 211       template<typename _Alloc>
 212         _GLIBCXX20_CONSTEXPR
 213         _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 214         : _M_head_impl(*__a._M_a) { }
 215
 216       template<typename _UHead>
 217         _GLIBCXX20_CONSTEXPR
 218         _Head_base(__uses_alloc0, _UHead&& __uhead)
 219         : _M_head_impl(std::forward<_UHead>(__uhead)) { }
 220
 221       template<typename _Alloc, typename _UHead>
 222         _GLIBCXX20_CONSTEXPR
 223         _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 224         : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 225         { }
 226
 227       template<typename _Alloc, typename _UHead>
 228         _GLIBCXX20_CONSTEXPR
 229         _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 230         : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
 231
 232       static constexpr _Head&
 233       _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
 234
 235       static constexpr const _Head&
 236       _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
 237
 238       _Head _M_head_impl;
 239     };
 240
 241   /**
 242    * Contains the actual implementation of the @c tuple template, stored
 243    * as a recursive inheritance hierarchy from the first element (most
 244    * derived class) to the last (least derived class). The @c Idx
 245    * parameter gives the 0-based index of the element stored at this
 246    * point in the hierarchy; we use it to implement a constant-time
 247    * get() operation.
 248    */
 249   template<size_t _Idx, typename... _Elements>
 250     struct _Tuple_impl;
 251
 252   /**
 253    * Recursive tuple implementation. Here we store the @c Head element
 254    * and derive from a @c Tuple_impl containing the remaining elements
 255    * (which contains the @c Tail).
 256    */
 257   template<size_t _Idx, typename _Head, typename... _Tail>
 258     struct _Tuple_impl<_Idx, _Head, _Tail...>
 259     : public _Tuple_impl<_Idx + 1, _Tail...>,
 260       private _Head_base<_Idx, _Head>
 261     {
 262       template<size_t, typename...> friend struct _Tuple_impl;
 263
 264       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
 265       typedef _Head_base<_Idx, _Head> _Base;
 266
 267       static constexpr _Head&
 268       _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 269
 270       static constexpr const _Head&
 271       _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 272
 273       static constexpr _Inherited&
 274       _M_tail(_Tuple_impl& __t) noexcept { return __t; }
 275
 276       static constexpr const _Inherited&
 277       _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
 278
 279       constexpr _Tuple_impl()
 280       : _Inherited(), _Base() { }
 281
 282       explicit constexpr
 283       _Tuple_impl(const _Head& __head, const _Tail&... __tail)
 284       : _Inherited(__tail...), _Base(__head)
 285       { }
 286
 287       template<typename _UHead, typename... _UTail,
 288                typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 289         explicit constexpr
 290         _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 291         : _Inherited(std::forward<_UTail>(__tail)...),
 292           _Base(std::forward<_UHead>(__head))
 293         { }
 294
 295       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 296
 297       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 298       // 2729. Missing SFINAE on std::pair::operator=
 299       _Tuple_impl& operator=(const _Tuple_impl&) = delete;
 300
 301       _Tuple_impl(_Tuple_impl&&) = default;
 302
 303       template<typename... _UElements>
 304         constexpr
 305         _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 306         : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
 307           _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
 308         { }
 309
 310       template<typename _UHead, typename... _UTails>
 311         constexpr
 312         _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 313         : _Inherited(std::move
 314                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 315           _Base(std::forward<_UHead>
 316                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 317         { }
 318
 319       template<typename _Alloc>
 320         _GLIBCXX20_CONSTEXPR
 321         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 322         : _Inherited(__tag, __a),
 323           _Base(__tag, __use_alloc<_Head>(__a))
 324         { }
 325
 326       template<typename _Alloc>
 327         _GLIBCXX20_CONSTEXPR
 328         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 329                     const _Head& __head, const _Tail&... __tail)
 330         : _Inherited(__tag, __a, __tail...),
 331           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
 332         { }
 333
 334       template<typename _Alloc, typename _UHead, typename... _UTail,
 335                typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 336         _GLIBCXX20_CONSTEXPR
 337         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 338                     _UHead&& __head, _UTail&&... __tail)
 339         : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
 340           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 341                 std::forward<_UHead>(__head))
 342         { }
 343
 344       template<typename _Alloc>
 345         _GLIBCXX20_CONSTEXPR
 346         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 347                     const _Tuple_impl& __in)
 348         : _Inherited(__tag, __a, _M_tail(__in)),
 349           _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
 350         { }
 351
 352       template<typename _Alloc>
 353         _GLIBCXX20_CONSTEXPR
 354         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 355                     _Tuple_impl&& __in)
 356         : _Inherited(__tag, __a, std::move(_M_tail(__in))),
 357           _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 358                 std::forward<_Head>(_M_head(__in)))
 359         { }
 360
 361       template<typename _Alloc, typename _UHead, typename... _UTails>
 362         _GLIBCXX20_CONSTEXPR
 363         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 364                     const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
 365         : _Inherited(__tag, __a,
 366                      _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
 367           _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
 368                 _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
 369         { }
 370
 371       template<typename _Alloc, typename _UHead, typename... _UTails>
 372         _GLIBCXX20_CONSTEXPR
 373         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 374                     _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 375         : _Inherited(__tag, __a, std::move
 376                      (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
 377           _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 378                 std::forward<_UHead>
 379                 (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 380         { }
 381
 382       template<typename... _UElements>
 383         _GLIBCXX20_CONSTEXPR
 384         void
 385         _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
 386         {
 387           _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
 388           _M_tail(*this)._M_assign(
 389               _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
 390         }
 391
 392       template<typename _UHead, typename... _UTails>
 393         _GLIBCXX20_CONSTEXPR
 394         void
 395         _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 396         {
 397           _M_head(*this) = std::forward<_UHead>
 398             (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
 399           _M_tail(*this)._M_assign(
 400               std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
 401         }
 402
 403     protected:
 404       _GLIBCXX20_CONSTEXPR
 405       void
 406       _M_swap(_Tuple_impl& __in)
 407       {
 408         using std::swap;
 409         swap(_M_head(*this), _M_head(__in));
 410         _Inherited::_M_swap(_M_tail(__in));
 411       }
 412     };
 413
 414   // Basis case of inheritance recursion.
 415   template<size_t _Idx, typename _Head>
 416     struct _Tuple_impl<_Idx, _Head>
 417     : private _Head_base<_Idx, _Head>
 418     {
 419       template<size_t, typename...> friend struct _Tuple_impl;
 420
 421       typedef _Head_base<_Idx, _Head> _Base;
 422
 423       static constexpr _Head&
 424       _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 425
 426       static constexpr const _Head&
 427       _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
 428
 429       constexpr
 430       _Tuple_impl()
 431       : _Base() { }
 432
 433       explicit constexpr
 434       _Tuple_impl(const _Head& __head)
 435       : _Base(__head)
 436       { }
 437
 438       template<typename _UHead>
 439         explicit constexpr
 440         _Tuple_impl(_UHead&& __head)
 441         : _Base(std::forward<_UHead>(__head))
 442         { }
 443
 444       constexpr _Tuple_impl(const _Tuple_impl&) = default;
 445
 446       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 447       // 2729. Missing SFINAE on std::pair::operator=
 448       _Tuple_impl& operator=(const _Tuple_impl&) = delete;
 449
 450 #if _GLIBCXX_INLINE_VERSION
 451       _Tuple_impl(_Tuple_impl&&) = default;
 452 #else
 453       constexpr
 454       _Tuple_impl(_Tuple_impl&& __in)
 455       noexcept(is_nothrow_move_constructible<_Head>::value)
 456       : _Base(static_cast<_Base&&>(__in))
 457       { }
 458 #endif
 459
 460       template<typename _UHead>
 461         constexpr
 462         _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
 463         : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
 464         { }
 465
 466       template<typename _UHead>
 467         constexpr
 468         _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
 469         : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 470         { }
 471
 472       template<typename _Alloc>
 473         _GLIBCXX20_CONSTEXPR
 474         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 475         : _Base(__tag, __use_alloc<_Head>(__a))
 476         { }
 477
 478       template<typename _Alloc>
 479         _GLIBCXX20_CONSTEXPR
 480         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 481                     const _Head& __head)
 482         : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
 483         { }
 484
 485       template<typename _Alloc, typename _UHead>
 486         _GLIBCXX20_CONSTEXPR
 487         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 488                     _UHead&& __head)
 489         : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 490                 std::forward<_UHead>(__head))
 491         { }
 492
 493       template<typename _Alloc>
 494         _GLIBCXX20_CONSTEXPR
 495         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 496                     const _Tuple_impl& __in)
 497         : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
 498         { }
 499
 500       template<typename _Alloc>
 501         _GLIBCXX20_CONSTEXPR
 502         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 503                     _Tuple_impl&& __in)
 504         : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
 505                 std::forward<_Head>(_M_head(__in)))
 506         { }
 507
 508       template<typename _Alloc, typename _UHead>
 509         _GLIBCXX20_CONSTEXPR
 510         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 511                     const _Tuple_impl<_Idx, _UHead>& __in)
 512         : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
 513                 _Tuple_impl<_Idx, _UHead>::_M_head(__in))
 514         { }
 515
 516       template<typename _Alloc, typename _UHead>
 517         _GLIBCXX20_CONSTEXPR
 518         _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
 519                     _Tuple_impl<_Idx, _UHead>&& __in)
 520         : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
 521                 std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 522         { }
 523
 524       template<typename _UHead>
 525         _GLIBCXX20_CONSTEXPR
 526         void
 527         _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
 528         {
 529           _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 530         }
 531
 532       template<typename _UHead>
 533         _GLIBCXX20_CONSTEXPR
 534         void
 535         _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
 536         {
 537           _M_head(*this)
 538             = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 539         }
 540
 541     protected:
 542       _GLIBCXX20_CONSTEXPR
 543       void
 544       _M_swap(_Tuple_impl& __in)
 545       {
 546         using std::swap;
 547         swap(_M_head(*this), _M_head(__in));
 548       }
 549     };
 550
 551   // Concept utility functions, reused in conditionally-explicit
 552   // constructors.
 553   template<bool, typename... _Types>
 554     struct _TupleConstraints
 555     {
 556       // Constraint for a non-explicit constructor.
 557       // True iff each Ti in _Types... can be constructed from Ui in _UTypes...
 558       // and every Ui is implicitly convertible to Ti.
 559       template<typename... _UTypes>
 560         static constexpr bool __is_implicitly_constructible()
 561         {
 562           return __and_<is_constructible<_Types, _UTypes>...,
 563                         is_convertible<_UTypes, _Types>...
 564                         >::value;
 565         }
 566
 567       // Constraint for a non-explicit constructor.
 568       // True iff each Ti in _Types... can be constructed from Ui in _UTypes...
 569       // but not every Ui is implicitly convertible to Ti.
 570       template<typename... _UTypes>
 571         static constexpr bool __is_explicitly_constructible()
 572         {
 573           return __and_<is_constructible<_Types, _UTypes>...,
 574                         __not_<__and_<is_convertible<_UTypes, _Types>...>>
 575                         >::value;
 576         }
 577
 578       static constexpr bool __is_implicitly_default_constructible()
 579       {
 580         return __and_<std::__is_implicitly_default_constructible<_Types>...
 581                       >::value;
 582       }
 583
 584       static constexpr bool __is_explicitly_default_constructible()
 585       {
 586         return __and_<is_default_constructible<_Types>...,
 587                       __not_<__and_<
 588                         std::__is_implicitly_default_constructible<_Types>...>
 589                       >>::value;
 590       }
 591     };
 592
 593   // Partial specialization used when a required precondition isn't met,
 594   // e.g. when sizeof...(_Types) != sizeof...(_UTypes).
 595   template<typename... _Types>
 596     struct _TupleConstraints<false, _Types...>
 597     {
 598       template<typename... _UTypes>
 599         static constexpr bool __is_implicitly_constructible()
 600         { return false; }
 601
 602       template<typename... _UTypes>
 603         static constexpr bool __is_explicitly_constructible()
 604         { return false; }
 605     };
 606
 607   /// Primary class template, tuple
 608   template<typename... _Elements>
 609     class tuple : public _Tuple_impl<0, _Elements...>
 610     {
 611       typedef _Tuple_impl<0, _Elements...> _Inherited;
 612
 613       template<bool _Cond>
 614         using _TCC = _TupleConstraints<_Cond, _Elements...>;
 615
 616       // Constraint for non-explicit default constructor
 617       template<bool _Dummy>
 618         using _ImplicitDefaultCtor = __enable_if_t<
 619           _TCC<_Dummy>::__is_implicitly_default_constructible(),
 620           bool>;
 621
 622       // Constraint for explicit default constructor
 623       template<bool _Dummy>
 624         using _ExplicitDefaultCtor = __enable_if_t<
 625           _TCC<_Dummy>::__is_explicitly_default_constructible(),
 626           bool>;
 627
 628       // Constraint for non-explicit constructors
 629       template<bool _Cond, typename... _Args>
 630         using _ImplicitCtor = __enable_if_t<
 631           _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
 632           bool>;
 633
 634       // Constraint for non-explicit constructors
 635       template<bool _Cond, typename... _Args>
 636         using _ExplicitCtor = __enable_if_t<
 637           _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
 638           bool>;
 639
 640       template<typename... _UElements>
 641         static constexpr
 642         __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
 643         __assignable()
 644         { return __and_<is_assignable<_Elements&, _UElements>...>::value; }
 645
 646       // Condition for noexcept-specifier of an assignment operator.
 647       template<typename... _UElements>
 648         static constexpr bool __nothrow_assignable()
 649         {
 650           return
 651             __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
 652         }
 653
 654       // Condition for noexcept-specifier of a constructor.
 655       template<typename... _UElements>
 656         static constexpr bool __nothrow_constructible()
 657         {
 658           return
 659             __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
 660         }
 661
 662       // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) == 1.
 663       template<typename _Up>
 664         static constexpr bool __valid_args()
 665         {
 666           return sizeof...(_Elements) == 1
 667             && !is_same<tuple, __remove_cvref_t<_Up>>::value;
 668         }
 669
 670       // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) > 1.
 671       template<typename, typename, typename... _Tail>
 672         static constexpr bool __valid_args()
 673         { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); }
 674
 675       /* Constraint for constructors with a tuple<UTypes...> parameter ensures
 676        * that the constructor is only viable when it would not interfere with
 677        * tuple(UTypes&&...) or tuple(const tuple&) or tuple(tuple&&).
 678        * Such constructors are only viable if:
 679        * either sizeof...(Types) != 1,
 680        * or (when Types... expands to T and UTypes... expands to U)
 681        * is_convertible_v<TUPLE, T>, is_constructible_v<T, TUPLE>,
 682        * and is_same_v<T, U> are all false.
 683        */
 684       template<typename _Tuple, typename = tuple,
 685                typename = __remove_cvref_t<_Tuple>>
 686         struct _UseOtherCtor
 687         : false_type
 688         { };
 689       // If TUPLE is convertible to the single element in *this,
 690       // then TUPLE should match tuple(UTypes&&...) instead.
 691       template<typename _Tuple, typename _Tp, typename _Up>
 692         struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>>
 693         : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>
 694         { };
 695       // If TUPLE and *this each have a single element of the same type,
 696       // then TUPLE should match a copy/move constructor instead.
 697       template<typename _Tuple, typename _Tp>
 698         struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>>
 699         : true_type
 700         { };
 701
 702       // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1
 703       // and the single element in Types can be initialized from TUPLE,
 704       // or is the same type as tuple_element_t<0, TUPLE>.
 705       template<typename _Tuple>
 706         static constexpr bool __use_other_ctor()
 707         { return _UseOtherCtor<_Tuple>::value; }
 708
 709     public:
 710       template<typename _Dummy = void,
 711                _ImplicitDefaultCtor<is_void<_Dummy>::value> = true>
 712         constexpr
 713         tuple()
 714         noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
 715         : _Inherited() { }
 716
 717       template<typename _Dummy = void,
 718                _ExplicitDefaultCtor<is_void<_Dummy>::value> = false>
 719         explicit constexpr
 720         tuple()
 721         noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
 722         : _Inherited() { }
 723
 724       template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
 725                _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
 726         constexpr
 727         tuple(const _Elements&... __elements)
 728         noexcept(__nothrow_constructible<const _Elements&...>())
 729         : _Inherited(__elements...) { }
 730
 731       template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
 732                _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
 733         explicit constexpr
 734         tuple(const _Elements&... __elements)
 735         noexcept(__nothrow_constructible<const _Elements&...>())
 736         : _Inherited(__elements...) { }
 737
 738       template<typename... _UElements,
 739                bool _Valid = __valid_args<_UElements...>(),
 740                _ImplicitCtor<_Valid, _UElements...> = true>
 741         constexpr
 742         tuple(_UElements&&... __elements)
 743         noexcept(__nothrow_constructible<_UElements...>())
 744         : _Inherited(std::forward<_UElements>(__elements)...) { }
 745
 746       template<typename... _UElements,
 747                bool _Valid = __valid_args<_UElements...>(),
 748                _ExplicitCtor<_Valid, _UElements...> = false>
 749         explicit constexpr
 750         tuple(_UElements&&... __elements)
 751         noexcept(__nothrow_constructible<_UElements...>())
 752         : _Inherited(std::forward<_UElements>(__elements)...) { }
 753
 754       constexpr tuple(const tuple&) = default;
 755
 756       constexpr tuple(tuple&&) = default;
 757
 758       template<typename... _UElements,
 759                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 760                            && !__use_other_ctor<const tuple<_UElements...>&>(),
 761                _ImplicitCtor<_Valid, const _UElements&...> = true>
 762         constexpr
 763         tuple(const tuple<_UElements...>& __in)
 764         noexcept(__nothrow_constructible<const _UElements&...>())
 765         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 766         { }
 767
 768       template<typename... _UElements,
 769                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 770                            && !__use_other_ctor<const tuple<_UElements...>&>(),
 771                _ExplicitCtor<_Valid, const _UElements&...> = false>
 772         explicit constexpr
 773         tuple(const tuple<_UElements...>& __in)
 774         noexcept(__nothrow_constructible<const _UElements&...>())
 775         : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 776         { }
 777
 778       template<typename... _UElements,
 779                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 780                              && !__use_other_ctor<tuple<_UElements...>&&>(),
 781                _ImplicitCtor<_Valid, _UElements...> = true>
 782         constexpr
 783         tuple(tuple<_UElements...>&& __in)
 784         noexcept(__nothrow_constructible<_UElements...>())
 785         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 786
 787       template<typename... _UElements,
 788                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 789                              && !__use_other_ctor<tuple<_UElements...>&&>(),
 790                _ExplicitCtor<_Valid, _UElements...> = false>
 791         explicit constexpr
 792         tuple(tuple<_UElements...>&& __in)
 793         noexcept(__nothrow_constructible<_UElements...>())
 794         : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
 795
 796       // Allocator-extended constructors.
 797
 798       template<typename _Alloc,
 799                _ImplicitDefaultCtor<is_object<_Alloc>::value> = true>
 800         _GLIBCXX20_CONSTEXPR
 801         tuple(allocator_arg_t __tag, const _Alloc& __a)
 802         : _Inherited(__tag, __a) { }
 803
 804       template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
 805                _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
 806         _GLIBCXX20_CONSTEXPR
 807         tuple(allocator_arg_t __tag, const _Alloc& __a,
 808               const _Elements&... __elements)
 809         : _Inherited(__tag, __a, __elements...) { }
 810
 811       template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
 812                _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
 813         _GLIBCXX20_CONSTEXPR
 814         explicit
 815         tuple(allocator_arg_t __tag, const _Alloc& __a,
 816               const _Elements&... __elements)
 817         : _Inherited(__tag, __a, __elements...) { }
 818
 819       template<typename _Alloc, typename... _UElements,
 820                bool _Valid = __valid_args<_UElements...>(),
 821                _ImplicitCtor<_Valid, _UElements...> = true>
 822         _GLIBCXX20_CONSTEXPR
 823         tuple(allocator_arg_t __tag, const _Alloc& __a,
 824               _UElements&&... __elements)
 825         : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 826         { }
 827
 828       template<typename _Alloc, typename... _UElements,
 829                  bool _Valid = __valid_args<_UElements...>(),
 830                _ExplicitCtor<_Valid, _UElements...> = false>
 831         _GLIBCXX20_CONSTEXPR
 832         explicit
 833         tuple(allocator_arg_t __tag, const _Alloc& __a,
 834               _UElements&&... __elements)
 835         : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
 836         { }
 837
 838       template<typename _Alloc>
 839         _GLIBCXX20_CONSTEXPR
 840         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
 841         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
 842
 843       template<typename _Alloc>
 844         _GLIBCXX20_CONSTEXPR
 845         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
 846         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
 847
 848       template<typename _Alloc, typename... _UElements,
 849                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 850                              && !__use_other_ctor<const tuple<_UElements...>&>(),
 851                _ImplicitCtor<_Valid, const _UElements&...> = true>
 852         _GLIBCXX20_CONSTEXPR
 853         tuple(allocator_arg_t __tag, const _Alloc& __a,
 854               const tuple<_UElements...>& __in)
 855         : _Inherited(__tag, __a,
 856                      static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 857         { }
 858
 859       template<typename _Alloc, typename... _UElements,
 860                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 861                              && !__use_other_ctor<const tuple<_UElements...>&>(),
 862                _ExplicitCtor<_Valid, const _UElements&...> = false>
 863         _GLIBCXX20_CONSTEXPR
 864         explicit
 865         tuple(allocator_arg_t __tag, const _Alloc& __a,
 866               const tuple<_UElements...>& __in)
 867         : _Inherited(__tag, __a,
 868                      static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
 869         { }
 870
 871       template<typename _Alloc, typename... _UElements,
 872                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 873                              && !__use_other_ctor<tuple<_UElements...>&&>(),
 874                _ImplicitCtor<_Valid, _UElements...> = true>
 875         _GLIBCXX20_CONSTEXPR
 876         tuple(allocator_arg_t __tag, const _Alloc& __a,
 877               tuple<_UElements...>&& __in)
 878         : _Inherited(__tag, __a,
 879                      static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 880         { }
 881
 882       template<typename _Alloc, typename... _UElements,
 883                bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
 884                              && !__use_other_ctor<tuple<_UElements...>&&>(),
 885                _ExplicitCtor<_Valid, _UElements...> = false>
 886         _GLIBCXX20_CONSTEXPR
 887         explicit
 888         tuple(allocator_arg_t __tag, const _Alloc& __a,
 889               tuple<_UElements...>&& __in)
 890         : _Inherited(__tag, __a,
 891                      static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
 892         { }
 893
 894       // tuple assignment
 895
 896       _GLIBCXX20_CONSTEXPR
 897       tuple&
 898       operator=(__conditional_t<__assignable<const _Elements&...>(),
 899                                 const tuple&,
 900                                 const __nonesuch&> __in)
 901       noexcept(__nothrow_assignable<const _Elements&...>())
 902       {
 903         this->_M_assign(__in);
 904         return *this;
 905       }
 906
 907       _GLIBCXX20_CONSTEXPR
 908       tuple&
 909       operator=(__conditional_t<__assignable<_Elements...>(),
 910                                 tuple&&,
 911                                 __nonesuch&&> __in)
 912       noexcept(__nothrow_assignable<_Elements...>())
 913       {
 914         this->_M_assign(std::move(__in));
 915         return *this;
 916       }
 917
 918       template<typename... _UElements>
 919         _GLIBCXX20_CONSTEXPR
 920         __enable_if_t<__assignable<const _UElements&...>(), tuple&>
 921         operator=(const tuple<_UElements...>& __in)
 922         noexcept(__nothrow_assignable<const _UElements&...>())
 923         {
 924           this->_M_assign(__in);
 925           return *this;
 926         }
 927
 928       template<typename... _UElements>
 929         _GLIBCXX20_CONSTEXPR
 930         __enable_if_t<__assignable<_UElements...>(), tuple&>
 931         operator=(tuple<_UElements...>&& __in)
 932         noexcept(__nothrow_assignable<_UElements...>())
 933         {
 934           this->_M_assign(std::move(__in));
 935           return *this;
 936         }
 937
 938       // tuple swap
 939       _GLIBCXX20_CONSTEXPR
 940       void
 941       swap(tuple& __in)
 942       noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
 943       { _Inherited::_M_swap(__in); }
 944     };
 945
 946 #if __cpp_deduction_guides >= 201606
 947   template<typename... _UTypes>
 948     tuple(_UTypes...) -> tuple<_UTypes...>;
 949   template<typename _T1, typename _T2>
 950     tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
 951   template<typename _Alloc, typename... _UTypes>
 952     tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
 953   template<typename _Alloc, typename _T1, typename _T2>
 954     tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
 955   template<typename _Alloc, typename... _UTypes>
 956     tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
 957 #endif
 958
 959   // Explicit specialization, zero-element tuple.
 960   template<>
 961     class tuple<>
 962     {
 963     public:
 964       _GLIBCXX20_CONSTEXPR
 965       void swap(tuple&) noexcept { /* no-op */ }
 966       // We need the default since we're going to define no-op
 967       // allocator constructors.
 968       tuple() = default;
 969       // No-op allocator constructors.
 970       template<typename _Alloc>
 971         _GLIBCXX20_CONSTEXPR
 972         tuple(allocator_arg_t, const _Alloc&) noexcept { }
 973       template<typename _Alloc>
 974         _GLIBCXX20_CONSTEXPR
 975         tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
 976     };
 977
 978   /// Partial specialization, 2-element tuple.
 979   /// Includes construction and assignment from a pair.
 980   template<typename _T1, typename _T2>
 981     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
 982     {
 983       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
 984
 985       // Constraint for non-explicit default constructor
 986       template<bool _Dummy, typename _U1, typename _U2>
 987         using _ImplicitDefaultCtor = __enable_if_t<
 988           _TupleConstraints<_Dummy, _U1, _U2>::
 989             __is_implicitly_default_constructible(),
 990           bool>;
 991
 992       // Constraint for explicit default constructor
 993       template<bool _Dummy, typename _U1, typename _U2>
 994         using _ExplicitDefaultCtor = __enable_if_t<
 995           _TupleConstraints<_Dummy, _U1, _U2>::
 996             __is_explicitly_default_constructible(),
 997           bool>;
 998
 999       template<bool _Dummy>
1000         using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;
1001
1002       // Constraint for non-explicit constructors
1003       template<bool _Cond, typename _U1, typename _U2>
1004         using _ImplicitCtor = __enable_if_t<
1005           _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
1006           bool>;
1007
1008       // Constraint for non-explicit constructors
1009       template<bool _Cond, typename _U1, typename _U2>
1010         using _ExplicitCtor = __enable_if_t<
1011           _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
1012           bool>;
1013
1014       template<typename _U1, typename _U2>
1015         static constexpr bool __assignable()
1016         {
1017           return __and_<is_assignable<_T1&, _U1>,
1018                         is_assignable<_T2&, _U2>>::value;
1019         }
1020
1021       template<typename _U1, typename _U2>
1022         static constexpr bool __nothrow_assignable()
1023         {
1024           return __and_<is_nothrow_assignable<_T1&, _U1>,
1025                         is_nothrow_assignable<_T2&, _U2>>::value;
1026         }
1027
1028       template<typename _U1, typename _U2>
1029         static constexpr bool __nothrow_constructible()
1030         {
1031           return __and_<is_nothrow_constructible<_T1, _U1>,
1032                             is_nothrow_constructible<_T2, _U2>>::value;
1033         }
1034
1035       static constexpr bool __nothrow_default_constructible()
1036       {
1037         return __and_<is_nothrow_default_constructible<_T1>,
1038                       is_nothrow_default_constructible<_T2>>::value;
1039       }
1040
1041       template<typename _U1>
1042         static constexpr bool __is_alloc_arg()
1043         { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; }
1044
1045     public:
1046       template<bool _Dummy = true,
1047                _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true>
1048         constexpr
1049         tuple()
1050         noexcept(__nothrow_default_constructible())
1051         : _Inherited() { }
1052
1053       template<bool _Dummy = true,
1054                _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false>
1055         explicit constexpr
1056         tuple()
1057         noexcept(__nothrow_default_constructible())
1058         : _Inherited() { }
1059
1060       template<bool _Dummy = true,
1061                _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
1062         constexpr
1063         tuple(const _T1& __a1, const _T2& __a2)
1064         noexcept(__nothrow_constructible<const _T1&, const _T2&>())
1065         : _Inherited(__a1, __a2) { }
1066
1067       template<bool _Dummy = true,
1068                _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
1069         explicit constexpr
1070         tuple(const _T1& __a1, const _T2& __a2)
1071         noexcept(__nothrow_constructible<const _T1&, const _T2&>())
1072         : _Inherited(__a1, __a2) { }
1073
1074       template<typename _U1, typename _U2,
1075                _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true>
1076         constexpr
1077         tuple(_U1&& __a1, _U2&& __a2)
1078         noexcept(__nothrow_constructible<_U1, _U2>())
1079         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
1080
1081       template<typename _U1, typename _U2,
1082                _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false>
1083         explicit constexpr
1084         tuple(_U1&& __a1, _U2&& __a2)
1085         noexcept(__nothrow_constructible<_U1, _U2>())
1086         : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
1087
1088       constexpr tuple(const tuple&) = default;
1089
1090       constexpr tuple(tuple&&) = default;
1091
1092       template<typename _U1, typename _U2,
1093                _ImplicitCtor<true, const _U1&, const _U2&> = true>
1094         constexpr
1095         tuple(const tuple<_U1, _U2>& __in)
1096         noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1097         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
1098
1099       template<typename _U1, typename _U2,
1100                _ExplicitCtor<true, const _U1&, const _U2&> = false>
1101         explicit constexpr
1102         tuple(const tuple<_U1, _U2>& __in)
1103         noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1104         : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
1105
1106       template<typename _U1, typename _U2,
1107                _ImplicitCtor<true, _U1, _U2> = true>
1108         constexpr
1109         tuple(tuple<_U1, _U2>&& __in)
1110         noexcept(__nothrow_constructible<_U1, _U2>())
1111         : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1112
1113       template<typename _U1, typename _U2,
1114                _ExplicitCtor<true, _U1, _U2> = false>
1115         explicit constexpr
1116         tuple(tuple<_U1, _U2>&& __in)
1117         noexcept(__nothrow_constructible<_U1, _U2>())
1118         : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
1119
1120       template<typename _U1, typename _U2,
1121                _ImplicitCtor<true, const _U1&, const _U2&> = true>
1122         constexpr
1123         tuple(const pair<_U1, _U2>& __in)
1124         noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1125         : _Inherited(__in.first, __in.second) { }
1126
1127       template<typename _U1, typename _U2,
1128                _ExplicitCtor<true, const _U1&, const _U2&> = false>
1129         explicit constexpr
1130         tuple(const pair<_U1, _U2>& __in)
1131         noexcept(__nothrow_constructible<const _U1&, const _U2&>())
1132         : _Inherited(__in.first, __in.second) { }
1133
1134       template<typename _U1, typename _U2,
1135                _ImplicitCtor<true, _U1, _U2> = true>
1136         constexpr
1137         tuple(pair<_U1, _U2>&& __in)
1138         noexcept(__nothrow_constructible<_U1, _U2>())
1139         : _Inherited(std::forward<_U1>(__in.first),
1140                      std::forward<_U2>(__in.second)) { }
1141
1142       template<typename _U1, typename _U2,
1143                _ExplicitCtor<true, _U1, _U2> = false>
1144         explicit constexpr
1145         tuple(pair<_U1, _U2>&& __in)
1146         noexcept(__nothrow_constructible<_U1, _U2>())
1147         : _Inherited(std::forward<_U1>(__in.first),
1148                      std::forward<_U2>(__in.second)) { }
1149
1150       // Allocator-extended constructors.
1151
1152       template<typename _Alloc,
1153                _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true>
1154         _GLIBCXX20_CONSTEXPR
1155         tuple(allocator_arg_t __tag, const _Alloc& __a)
1156         : _Inherited(__tag, __a) { }
1157
1158       template<typename _Alloc, bool _Dummy = true,
1159                _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
1160         _GLIBCXX20_CONSTEXPR
1161         tuple(allocator_arg_t __tag, const _Alloc& __a,
1162               const _T1& __a1, const _T2& __a2)
1163         : _Inherited(__tag, __a, __a1, __a2) { }
1164
1165       template<typename _Alloc, bool _Dummy = true,
1166                _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
1167         explicit
1168         _GLIBCXX20_CONSTEXPR
1169         tuple(allocator_arg_t __tag, const _Alloc& __a,
1170               const _T1& __a1, const _T2& __a2)
1171         : _Inherited(__tag, __a, __a1, __a2) { }
1172
1173       template<typename _Alloc, typename _U1, typename _U2,
1174                _ImplicitCtor<true, _U1, _U2> = true>
1175         _GLIBCXX20_CONSTEXPR
1176         tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
1177         : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1178                      std::forward<_U2>(__a2)) { }
1179
1180       template<typename _Alloc, typename _U1, typename _U2,
1181                _ExplicitCtor<true, _U1, _U2> = false>
1182         explicit
1183         _GLIBCXX20_CONSTEXPR
1184         tuple(allocator_arg_t __tag, const _Alloc& __a,
1185               _U1&& __a1, _U2&& __a2)
1186         : _Inherited(__tag, __a, std::forward<_U1>(__a1),
1187                      std::forward<_U2>(__a2)) { }
1188
1189       template<typename _Alloc>
1190         _GLIBCXX20_CONSTEXPR
1191         tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
1192         : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
1193
1194       template<typename _Alloc>
1195         _GLIBCXX20_CONSTEXPR
1196         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
1197         : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
1198
1199       template<typename _Alloc, typename _U1, typename _U2,
1200                _ImplicitCtor<true, const _U1&, const _U2&> = true>
1201         _GLIBCXX20_CONSTEXPR
1202         tuple(allocator_arg_t __tag, const _Alloc& __a,
1203               const tuple<_U1, _U2>& __in)
1204         : _Inherited(__tag, __a,
1205                      static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1206         { }
1207
1208       template<typename _Alloc, typename _U1, typename _U2,
1209                _ExplicitCtor<true, const _U1&, const _U2&> = false>
1210         explicit
1211         _GLIBCXX20_CONSTEXPR
1212         tuple(allocator_arg_t __tag, const _Alloc& __a,
1213               const tuple<_U1, _U2>& __in)
1214         : _Inherited(__tag, __a,
1215                      static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
1216         { }
1217
1218       template<typename _Alloc, typename _U1, typename _U2,
1219                _ImplicitCtor<true, _U1, _U2> = true>
1220         _GLIBCXX20_CONSTEXPR
1221         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1222         : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1223         { }
1224
1225       template<typename _Alloc, typename _U1, typename _U2,
1226                _ExplicitCtor<true, _U1, _U2> = false>
1227         explicit
1228         _GLIBCXX20_CONSTEXPR
1229         tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
1230         : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
1231         { }
1232
1233       template<typename _Alloc, typename _U1, typename _U2,
1234                _ImplicitCtor<true, const _U1&, const _U2&> = true>
1235         _GLIBCXX20_CONSTEXPR
1236         tuple(allocator_arg_t __tag, const _Alloc& __a,
1237               const pair<_U1, _U2>& __in)
1238         : _Inherited(__tag, __a, __in.first, __in.second) { }
1239
1240       template<typename _Alloc, typename _U1, typename _U2,
1241                _ExplicitCtor<true, const _U1&, const _U2&> = false>
1242         explicit
1243         _GLIBCXX20_CONSTEXPR
1244         tuple(allocator_arg_t __tag, const _Alloc& __a,
1245               const pair<_U1, _U2>& __in)
1246         : _Inherited(__tag, __a, __in.first, __in.second) { }
1247
1248       template<typename _Alloc, typename _U1, typename _U2,
1249                _ImplicitCtor<true, _U1, _U2> = true>
1250         _GLIBCXX20_CONSTEXPR
1251         tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1252         : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1253                      std::forward<_U2>(__in.second)) { }
1254
1255       template<typename _Alloc, typename _U1, typename _U2,
1256                _ExplicitCtor<true, _U1, _U2> = false>
1257         explicit
1258         _GLIBCXX20_CONSTEXPR
1259         tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
1260         : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
1261                      std::forward<_U2>(__in.second)) { }
1262
1263       // Tuple assignment.
1264
1265       _GLIBCXX20_CONSTEXPR
1266       tuple&
1267       operator=(__conditional_t<__assignable<const _T1&, const _T2&>(),
1268                                 const tuple&,
1269                                 const __nonesuch&> __in)
1270       noexcept(__nothrow_assignable<const _T1&, const _T2&>())
1271       {
1272         this->_M_assign(__in);
1273         return *this;
1274       }
1275
1276       _GLIBCXX20_CONSTEXPR
1277       tuple&
1278       operator=(__conditional_t<__assignable<_T1, _T2>(),
1279                                 tuple&&,
1280                                 __nonesuch&&> __in)
1281       noexcept(__nothrow_assignable<_T1, _T2>())
1282       {
1283         this->_M_assign(std::move(__in));
1284         return *this;
1285       }
1286
1287       template<typename _U1, typename _U2>
1288         _GLIBCXX20_CONSTEXPR
1289         __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
1290         operator=(const tuple<_U1, _U2>& __in)
1291         noexcept(__nothrow_assignable<const _U1&, const _U2&>())
1292         {
1293           this->_M_assign(__in);
1294           return *this;
1295         }
1296
1297       template<typename _U1, typename _U2>
1298         _GLIBCXX20_CONSTEXPR
1299         __enable_if_t<__assignable<_U1, _U2>(), tuple&>
1300         operator=(tuple<_U1, _U2>&& __in)
1301         noexcept(__nothrow_assignable<_U1, _U2>())
1302         {
1303           this->_M_assign(std::move(__in));
1304           return *this;
1305         }
1306
1307       template<typename _U1, typename _U2>
1308         _GLIBCXX20_CONSTEXPR
1309         __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
1310         operator=(const pair<_U1, _U2>& __in)
1311         noexcept(__nothrow_assignable<const _U1&, const _U2&>())
1312         {
1313           this->_M_head(*this) = __in.first;
1314           this->_M_tail(*this)._M_head(*this) = __in.second;
1315           return *this;
1316         }
1317
1318       template<typename _U1, typename _U2>
1319         _GLIBCXX20_CONSTEXPR
1320         __enable_if_t<__assignable<_U1, _U2>(), tuple&>
1321         operator=(pair<_U1, _U2>&& __in)
1322         noexcept(__nothrow_assignable<_U1, _U2>())
1323         {
1324           this->_M_head(*this) = std::forward<_U1>(__in.first);
1325           this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1326           return *this;
1327         }
1328
1329       _GLIBCXX20_CONSTEXPR
1330       void
1331       swap(tuple& __in)
1332       noexcept(__and_<__is_nothrow_swappable<_T1>,
1333                       __is_nothrow_swappable<_T2>>::value)
1334       { _Inherited::_M_swap(__in); }
1335     };
1336
1337
1338   /// class tuple_size
1339   template<typename... _Elements>
1340     struct tuple_size<tuple<_Elements...>>
1341     : public integral_constant<size_t, sizeof...(_Elements)> { };
1342
1343 #if __cplusplus >= 201703L
1344   template<typename... _Types>
1345     inline constexpr size_t tuple_size_v<tuple<_Types...>>
1346       = sizeof...(_Types);
1347
1348   template<typename... _Types>
1349     inline constexpr size_t tuple_size_v<const tuple<_Types...>>
1350       = sizeof...(_Types);
1351 #endif
1352
1353   /// Trait to get the Ith element type from a tuple.
1354   template<size_t __i, typename... _Types>
1355     struct tuple_element<__i, tuple<_Types...>>
1356     {
1357       static_assert(__i < sizeof...(_Types), "tuple index must be in range");
1358
1359       using type = typename _Nth_type<__i, _Types...>::type;
1360     };
1361
1362   template<size_t __i, typename _Head, typename... _Tail>
1363     constexpr _Head&
1364     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1365     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1366
1367   template<size_t __i, typename _Head, typename... _Tail>
1368     constexpr const _Head&
1369     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1370     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1371
1372   // Deleted overload to improve diagnostics for invalid indices
1373   template<size_t __i, typename... _Types>
1374     __enable_if_t<(__i >= sizeof...(_Types))>
1375     __get_helper(const tuple<_Types...>&) = delete;
1376
1377   /// Return a reference to the ith element of a tuple.
1378   template<size_t __i, typename... _Elements>
1379     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1380     get(tuple<_Elements...>& __t) noexcept
1381     { return std::__get_helper<__i>(__t); }
1382
1383   /// Return a const reference to the ith element of a const tuple.
1384   template<size_t __i, typename... _Elements>
1385     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1386     get(const tuple<_Elements...>& __t) noexcept
1387     { return std::__get_helper<__i>(__t); }
1388
1389   /// Return an rvalue reference to the ith element of a tuple rvalue.
1390   template<size_t __i, typename... _Elements>
1391     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1392     get(tuple<_Elements...>&& __t) noexcept
1393     {
1394       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1395       return std::forward<__element_type>(std::__get_helper<__i>(__t));
1396     }
1397
1398   /// Return a const rvalue reference to the ith element of a const tuple rvalue.
1399   template<size_t __i, typename... _Elements>
1400     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
1401     get(const tuple<_Elements...>&& __t) noexcept
1402     {
1403       typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
1404       return std::forward<const __element_type>(std::__get_helper<__i>(__t));
1405     }
1406
1407   /// @cond undocumented
1408   // Deleted overload chosen for invalid indices.
1409   template<size_t __i, typename... _Elements>
1410     constexpr __enable_if_t<(__i >= sizeof...(_Elements))>
1411     get(const tuple<_Elements...>&) = delete;
1412   /// @endcond
1413
1414 #if __cplusplus >= 201402L
1415
1416 #define __cpp_lib_tuples_by_type 201304L
1417
1418   /// Return a reference to the unique element of type _Tp of a tuple.
1419   template <typename _Tp, typename... _Types>
1420     constexpr _Tp&
1421     get(tuple<_Types...>& __t) noexcept
1422     {
1423       constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
1424       static_assert(__idx < sizeof...(_Types),
1425           "the type T in std::get<T> must occur exactly once in the tuple");
1426       return std::__get_helper<__idx>(__t);
1427     }
1428
1429   /// Return a reference to the unique element of type _Tp of a tuple rvalue.
1430   template <typename _Tp, typename... _Types>
1431     constexpr _Tp&&
1432     get(tuple<_Types...>&& __t) noexcept
1433     {
1434       constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
1435       static_assert(__idx < sizeof...(_Types),
1436           "the type T in std::get<T> must occur exactly once in the tuple");
1437       return std::forward<_Tp>(std::__get_helper<__idx>(__t));
1438     }
1439
1440   /// Return a const reference to the unique element of type _Tp of a tuple.
1441   template <typename _Tp, typename... _Types>
1442     constexpr const _Tp&
1443     get(const tuple<_Types...>& __t) noexcept
1444     {
1445       constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
1446       static_assert(__idx < sizeof...(_Types),
1447           "the type T in std::get<T> must occur exactly once in the tuple");
1448       return std::__get_helper<__idx>(__t);
1449     }
1450
1451   /// Return a const reference to the unique element of type _Tp of
1452   /// a const tuple rvalue.
1453   template <typename _Tp, typename... _Types>
1454     constexpr const _Tp&&
1455     get(const tuple<_Types...>&& __t) noexcept
1456     {
1457       constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
1458       static_assert(__idx < sizeof...(_Types),
1459           "the type T in std::get<T> must occur exactly once in the tuple");
1460       return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
1461     }
1462 #endif
1463
1464   // This class performs the comparison operations on tuples
1465   template<typename _Tp, typename _Up, size_t __i, size_t __size>
1466     struct __tuple_compare
1467     {
1468       static constexpr bool
1469       __eq(const _Tp& __t, const _Up& __u)
1470       {
1471         return bool(std::get<__i>(__t) == std::get<__i>(__u))
1472           && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
1473       }
1474
1475       static constexpr bool
1476       __less(const _Tp& __t, const _Up& __u)
1477       {
1478         return bool(std::get<__i>(__t) < std::get<__i>(__u))
1479           || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
1480               && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
1481       }
1482     };
1483
1484   template<typename _Tp, typename _Up, size_t __size>
1485     struct __tuple_compare<_Tp, _Up, __size, __size>
1486     {
1487       static constexpr bool
1488       __eq(const _Tp&, const _Up&) { return true; }
1489
1490       static constexpr bool
1491       __less(const _Tp&, const _Up&) { return false; }
1492     };
1493
1494   template<typename... _TElements, typename... _UElements>
1495     constexpr bool
1496     operator==(const tuple<_TElements...>& __t,
1497                const tuple<_UElements...>& __u)
1498     {
1499       static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1500           "tuple objects can only be compared if they have equal sizes.");
1501       using __compare = __tuple_compare<tuple<_TElements...>,
1502                                         tuple<_UElements...>,
1503                                         0, sizeof...(_TElements)>;
1504       return __compare::__eq(__t, __u);
1505     }
1506
1507 #if __cpp_lib_three_way_comparison
1508   template<typename _Cat, typename _Tp, typename _Up>
1509     constexpr _Cat
1510     __tuple_cmp(const _Tp&, const _Up&, index_sequence<>)
1511     { return _Cat::equivalent; }
1512
1513   template<typename _Cat, typename _Tp, typename _Up,
1514            size_t _Idx0, size_t... _Idxs>
1515     constexpr _Cat
1516     __tuple_cmp(const _Tp& __t, const _Up& __u,
1517                 index_sequence<_Idx0, _Idxs...>)
1518     {
1519       auto __c
1520         = __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u));
1521       if (__c != 0)
1522         return __c;
1523       return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>());
1524     }
1525
1526   template<typename... _Tps, typename... _Ups>
1527     constexpr
1528     common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
1529     operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u)
1530     {
1531       using _Cat
1532         = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
1533       return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
1534     }
1535 #else
1536   template<typename... _TElements, typename... _UElements>
1537     constexpr bool
1538     operator<(const tuple<_TElements...>& __t,
1539               const tuple<_UElements...>& __u)
1540     {
1541       static_assert(sizeof...(_TElements) == sizeof...(_UElements),
1542           "tuple objects can only be compared if they have equal sizes.");
1543       using __compare = __tuple_compare<tuple<_TElements...>,
1544                                         tuple<_UElements...>,
1545                                         0, sizeof...(_TElements)>;
1546       return __compare::__less(__t, __u);
1547     }
1548
1549   template<typename... _TElements, typename... _UElements>
1550     constexpr bool
1551     operator!=(const tuple<_TElements...>& __t,
1552                const tuple<_UElements...>& __u)
1553     { return !(__t == __u); }
1554
1555   template<typename... _TElements, typename... _UElements>
1556     constexpr bool
1557     operator>(const tuple<_TElements...>& __t,
1558               const tuple<_UElements...>& __u)
1559     { return __u < __t; }
1560
1561   template<typename... _TElements, typename... _UElements>
1562     constexpr bool
1563     operator<=(const tuple<_TElements...>& __t,
1564                const tuple<_UElements...>& __u)
1565     { return !(__u < __t); }
1566
1567   template<typename... _TElements, typename... _UElements>
1568     constexpr bool
1569     operator>=(const tuple<_TElements...>& __t,
1570                const tuple<_UElements...>& __u)
1571     { return !(__t < __u); }
1572 #endif // three_way_comparison
1573
1574   // NB: DR 705.
1575   template<typename... _Elements>
1576     constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1577     make_tuple(_Elements&&... __args)
1578     {
1579       typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1580         __result_type;
1581       return __result_type(std::forward<_Elements>(__args)...);
1582     }
1583
1584   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1585   // 2275. Why is forward_as_tuple not constexpr?
1586   /// std::forward_as_tuple
1587   template<typename... _Elements>
1588     constexpr tuple<_Elements&&...>
1589     forward_as_tuple(_Elements&&... __args) noexcept
1590     { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1591
1592   // Declarations of std::array and its std::get overloads, so that
1593   // std::tuple_cat can use them if <tuple> is included before <array>.
1594
1595   template<typename _Tp, size_t _Nm> struct array;
1596
1597   template<size_t _Int, typename _Tp, size_t _Nm>
1598     constexpr _Tp&
1599     get(array<_Tp, _Nm>&) noexcept;
1600
1601   template<size_t _Int, typename _Tp, size_t _Nm>
1602     constexpr _Tp&&
1603     get(array<_Tp, _Nm>&&) noexcept;
1604
1605   template<size_t _Int, typename _Tp, size_t _Nm>
1606     constexpr const _Tp&
1607     get(const array<_Tp, _Nm>&) noexcept;
1608
1609   template<size_t _Int, typename _Tp, size_t _Nm>
1610     constexpr const _Tp&&
1611     get(const array<_Tp, _Nm>&&) noexcept;
1612
1613
1614   template<size_t, typename, typename, size_t>
1615     struct __make_tuple_impl;
1616
1617   template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
1618     struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
1619     : __make_tuple_impl<_Idx + 1,
1620                         tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
1621                         _Tuple, _Nm>
1622     { };
1623
1624   template<size_t _Nm, typename _Tuple, typename... _Tp>
1625     struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
1626     {
1627       typedef tuple<_Tp...> __type;
1628     };
1629
1630   template<typename _Tuple>
1631     struct __do_make_tuple
1632     : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
1633     { };
1634
1635   // Returns the std::tuple equivalent of a tuple-like type.
1636   template<typename _Tuple>
1637     struct __make_tuple
1638     : public __do_make_tuple<__remove_cvref_t<_Tuple>>
1639     { };
1640
1641   // Combines several std::tuple's into a single one.
1642   template<typename...>
1643     struct __combine_tuples;
1644
1645   template<>
1646     struct __combine_tuples<>
1647     {
1648       typedef tuple<> __type;
1649     };
1650
1651   template<typename... _Ts>
1652     struct __combine_tuples<tuple<_Ts...>>
1653     {
1654       typedef tuple<_Ts...> __type;
1655     };
1656
1657   template<typename... _T1s, typename... _T2s, typename... _Rem>
1658     struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
1659     {
1660       typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
1661                                         _Rem...>::__type __type;
1662     };
1663
1664   // Computes the result type of tuple_cat given a set of tuple-like types.
1665   template<typename... _Tpls>
1666     struct __tuple_cat_result
1667     {
1668       typedef typename __combine_tuples
1669         <typename __make_tuple<_Tpls>::__type...>::__type __type;
1670     };
1671
1672   // Helper to determine the index set for the first tuple-like
1673   // type of a given set.
1674   template<typename...>
1675     struct __make_1st_indices;
1676
1677   template<>
1678     struct __make_1st_indices<>
1679     {
1680       typedef _Index_tuple<> __type;
1681     };
1682
1683   template<typename _Tp, typename... _Tpls>
1684     struct __make_1st_indices<_Tp, _Tpls...>
1685     {
1686       typedef typename _Build_index_tuple<tuple_size<
1687         typename remove_reference<_Tp>::type>::value>::__type __type;
1688     };
1689
1690   // Performs the actual concatenation by step-wise expanding tuple-like
1691   // objects into the elements,  which are finally forwarded into the
1692   // result tuple.
1693   template<typename _Ret, typename _Indices, typename... _Tpls>
1694     struct __tuple_concater;
1695
1696   template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>
1697     struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
1698     {
1699       template<typename... _Us>
1700         static constexpr _Ret
1701         _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
1702         {
1703           typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1704           typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
1705           return __next::_S_do(std::forward<_Tpls>(__tps)...,
1706                                std::forward<_Us>(__us)...,
1707                                std::get<_Is>(std::forward<_Tp>(__tp))...);
1708         }
1709     };
1710
1711   template<typename _Ret>
1712     struct __tuple_concater<_Ret, _Index_tuple<>>
1713     {
1714       template<typename... _Us>
1715         static constexpr _Ret
1716         _S_do(_Us&&... __us)
1717         {
1718           return _Ret(std::forward<_Us>(__us)...);
1719         }
1720     };
1721
1722   template<typename... _Tps>
1723     struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
1724     { };
1725
1726   /// tuple_cat
1727   template<typename... _Tpls, typename = typename
1728            enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
1729     constexpr auto
1730     tuple_cat(_Tpls&&... __tpls)
1731     -> typename __tuple_cat_result<_Tpls...>::__type
1732     {
1733       typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
1734       typedef typename __make_1st_indices<_Tpls...>::__type __idx;
1735       typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
1736       return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
1737     }
1738
1739   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1740   // 2301. Why is tie not constexpr?
1741   /// tie
1742   template<typename... _Elements>
1743     constexpr tuple<_Elements&...>
1744     tie(_Elements&... __args) noexcept
1745     { return tuple<_Elements&...>(__args...); }
1746
1747   /// swap
1748   template<typename... _Elements>
1749     _GLIBCXX20_CONSTEXPR
1750     inline
1751 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1752     // Constrained free swap overload, see p0185r1
1753     typename enable_if<__and_<__is_swappable<_Elements>...>::value
1754       >::type
1755 #else
1756     void
1757 #endif
1758     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
1759     noexcept(noexcept(__x.swap(__y)))
1760     { __x.swap(__y); }
1761
1762 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
1763   template<typename... _Elements>
1764     _GLIBCXX20_CONSTEXPR
1765     typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
1766     swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
1767 #endif
1768
1769   // A class (and instance) which can be used in 'tie' when an element
1770   // of a tuple is not required.
1771   // _GLIBCXX14_CONSTEXPR
1772   // 2933. PR for LWG 2773 could be clearer
1773   struct _Swallow_assign
1774   {
1775     template<class _Tp>
1776       _GLIBCXX14_CONSTEXPR const _Swallow_assign&
1777       operator=(const _Tp&) const
1778       { return *this; }
1779   };
1780
1781   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1782   // 2773. Making std::ignore constexpr
1783   _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
1784
1785   /// Partial specialization for tuples
1786   template<typename... _Types, typename _Alloc>
1787     struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
1788
1789   // See stl_pair.h...
1790   /** "piecewise construction" using a tuple of arguments for each member.
1791    *
1792    * @param __first Arguments for the first member of the pair.
1793    * @param __second Arguments for the second member of the pair.
1794    *
1795    * The elements of each tuple will be used as the constructor arguments
1796    * for the data members of the pair.
1797   */
1798   template<class _T1, class _T2>
1799     template<typename... _Args1, typename... _Args2>
1800       _GLIBCXX20_CONSTEXPR
1801       inline
1802       pair<_T1, _T2>::
1803       pair(piecewise_construct_t,
1804            tuple<_Args1...> __first, tuple<_Args2...> __second)
1805       : pair(__first, __second,
1806              typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
1807              typename _Build_index_tuple<sizeof...(_Args2)>::__type())
1808       { }
1809
1810   template<class _T1, class _T2>
1811     template<typename... _Args1, size_t... _Indexes1,
1812              typename... _Args2, size_t... _Indexes2>
1813       _GLIBCXX20_CONSTEXPR inline
1814       pair<_T1, _T2>::
1815       pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
1816            _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
1817       : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
1818         second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
1819       { }
1820
1821 #if __cplusplus >= 201703L
1822
1823   // Unpack a std::tuple into a type trait and use its value.
1824   // For cv std::tuple<_Up> the result is _Trait<_Tp, cv _Up...>::value.
1825   // For cv std::tuple<_Up>& the result is _Trait<_Tp, cv _Up&...>::value.
1826   // Otherwise the result is false (because we don't know if std::get throws).
1827   template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
1828     inline constexpr bool __unpack_std_tuple = false;
1829
1830   template<template<typename...> class _Trait, typename _Tp, typename... _Up>
1831     inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
1832       = _Trait<_Tp, _Up...>::value;
1833
1834   template<template<typename...> class _Trait, typename _Tp, typename... _Up>
1835     inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
1836       = _Trait<_Tp, _Up&...>::value;
1837
1838   template<template<typename...> class _Trait, typename _Tp, typename... _Up>
1839     inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
1840       = _Trait<_Tp, const _Up...>::value;
1841
1842   template<template<typename...> class _Trait, typename _Tp, typename... _Up>
1843     inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
1844       = _Trait<_Tp, const _Up&...>::value;
1845
1846 # define __cpp_lib_apply 201603
1847
1848   template <typename _Fn, typename _Tuple, size_t... _Idx>
1849     constexpr decltype(auto)
1850     __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
1851     {
1852       return std::__invoke(std::forward<_Fn>(__f),
1853                            std::get<_Idx>(std::forward<_Tuple>(__t))...);
1854     }
1855
1856   template <typename _Fn, typename _Tuple>
1857     constexpr decltype(auto)
1858     apply(_Fn&& __f, _Tuple&& __t)
1859     noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
1860     {
1861       using _Indices
1862         = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
1863       return std::__apply_impl(std::forward<_Fn>(__f),
1864                                std::forward<_Tuple>(__t),
1865                                _Indices{});
1866     }
1867
1868 #define __cpp_lib_make_from_tuple  201606
1869
1870   template <typename _Tp, typename _Tuple, size_t... _Idx>
1871     constexpr _Tp
1872     __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
1873     { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
1874
1875   template <typename _Tp, typename _Tuple>
1876     constexpr _Tp
1877     make_from_tuple(_Tuple&& __t)
1878     noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
1879     {
1880       return __make_from_tuple_impl<_Tp>(
1881         std::forward<_Tuple>(__t),
1882         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
1883     }
1884 #endif // C++17
1885
1886   /// @}
1887
1888 _GLIBCXX_END_NAMESPACE_VERSION
1889 } // namespace std
1890
1891 #endif // C++11
1892
1893 #endif // _GLIBCXX_TUPLE