libstdc++-v3/include/std/optional

   1 // <optional> -*- C++ -*-
   2
   3 // Copyright (C) 2013-2020 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/optional
  26  *  This is a Standard C++ Library header.
  27  */
  28
  29 #ifndef _GLIBCXX_OPTIONAL
  30 #define _GLIBCXX_OPTIONAL 1
  31
  32 #pragma GCC system_header
  33
  34 #if __cplusplus >= 201703L
  35
  36 #include <utility>
  37 #include <type_traits>
  38 #include <exception>
  39 #include <new>
  40 #include <initializer_list>
  41 #include <bits/exception_defines.h>
  42 #include <bits/functional_hash.h>
  43 #include <bits/enable_special_members.h>
  44 #if __cplusplus > 201703L
  45 # include <compare>
  46 #endif
  47
  48 namespace std _GLIBCXX_VISIBILITY(default)
  49 {
  50 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  51
  52   /**
  53    *  @addtogroup utilities
  54    *  @{
  55    */
  56
  57 #define __cpp_lib_optional 201606L
  58
  59   template<typename _Tp>
  60     class optional;
  61
  62   /// Tag type to disengage optional objects.
  63   struct nullopt_t
  64   {
  65     // Do not user-declare default constructor at all for
  66     // optional_value = {} syntax to work.
  67     // nullopt_t() = delete;
  68
  69     // Used for constructing nullopt.
  70     enum class _Construct { _Token };
  71
  72     // Must be constexpr for nullopt_t to be literal.
  73     explicit constexpr nullopt_t(_Construct) { }
  74   };
  75
  76   /// Tag to disengage optional objects.
  77   inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
  78
  79   /**
  80    *  @brief Exception class thrown when a disengaged optional object is
  81    *  dereferenced.
  82    *  @ingroup exceptions
  83    */
  84   class bad_optional_access : public exception
  85   {
  86   public:
  87     bad_optional_access() = default;
  88     virtual ~bad_optional_access() = default;
  89
  90     const char* what() const noexcept override
  91     { return "bad optional access"; }
  92   };
  93
  94   void
  95   __throw_bad_optional_access()
  96   __attribute__((__noreturn__));
  97
  98   // XXX Does not belong here.
  99   inline void
 100   __throw_bad_optional_access()
 101   { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }
 102
 103   // This class template manages construction/destruction of
 104   // the contained value for a std::optional.
 105   template <typename _Tp>
 106     struct _Optional_payload_base
 107     {
 108       using _Stored_type = remove_const_t<_Tp>;
 109
 110       _Optional_payload_base() = default;
 111       ~_Optional_payload_base() = default;
 112
 113       template<typename... _Args>
 114         constexpr
 115         _Optional_payload_base(in_place_t __tag, _Args&&... __args)
 116         : _M_payload(__tag, std::forward<_Args>(__args)...),
 117           _M_engaged(true)
 118         { }
 119
 120       template<typename _Up, typename... _Args>
 121         constexpr
 122         _Optional_payload_base(std::initializer_list<_Up> __il,
 123                                _Args&&... __args)
 124         : _M_payload(__il, std::forward<_Args>(__args)...),
 125           _M_engaged(true)
 126         { }
 127
 128       // Constructor used by _Optional_base copy constructor when the
 129       // contained value is not trivially copy constructible.
 130       constexpr
 131       _Optional_payload_base(bool __engaged,
 132                              const _Optional_payload_base& __other)
 133       {
 134         if (__other._M_engaged)
 135           this->_M_construct(__other._M_get());
 136       }
 137
 138       // Constructor used by _Optional_base move constructor when the
 139       // contained value is not trivially move constructible.
 140       constexpr
 141       _Optional_payload_base(bool __engaged,
 142                              _Optional_payload_base&& __other)
 143       {
 144         if (__other._M_engaged)
 145           this->_M_construct(std::move(__other._M_get()));
 146       }
 147
 148       // Copy constructor is only used to when the contained value is
 149       // trivially copy constructible.
 150       _Optional_payload_base(const _Optional_payload_base&) = default;
 151
 152       // Move constructor is only used to when the contained value is
 153       // trivially copy constructible.
 154       _Optional_payload_base(_Optional_payload_base&&) = default;
 155
 156       _Optional_payload_base&
 157       operator=(const _Optional_payload_base&) = default;
 158
 159       _Optional_payload_base&
 160       operator=(_Optional_payload_base&&) = default;
 161
 162       // used to perform non-trivial copy assignment.
 163       constexpr void
 164       _M_copy_assign(const _Optional_payload_base& __other)
 165       {
 166         if (this->_M_engaged && __other._M_engaged)
 167           this->_M_get() = __other._M_get();
 168         else
 169           {
 170             if (__other._M_engaged)
 171               this->_M_construct(__other._M_get());
 172             else
 173               this->_M_reset();
 174           }
 175       }
 176
 177       // used to perform non-trivial move assignment.
 178       constexpr void
 179       _M_move_assign(_Optional_payload_base&& __other)
 180       noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
 181                        is_nothrow_move_assignable<_Tp>>)
 182       {
 183         if (this->_M_engaged && __other._M_engaged)
 184           this->_M_get() = std::move(__other._M_get());
 185         else
 186           {
 187             if (__other._M_engaged)
 188               this->_M_construct(std::move(__other._M_get()));
 189             else
 190               this->_M_reset();
 191           }
 192       }
 193
 194       struct _Empty_byte { };
 195
 196       template<typename _Up, bool = is_trivially_destructible_v<_Up>>
 197         union _Storage
 198         {
 199           constexpr _Storage() noexcept : _M_empty() { }
 200
 201           template<typename... _Args>
 202             constexpr
 203             _Storage(in_place_t, _Args&&... __args)
 204             : _M_value(std::forward<_Args>(__args)...)
 205             { }
 206
 207           template<typename _Vp, typename... _Args>
 208             constexpr
 209             _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
 210             : _M_value(__il, std::forward<_Args>(__args)...)
 211             { }
 212
 213           _Empty_byte _M_empty;
 214           _Up _M_value;
 215         };
 216
 217       template<typename _Up>
 218         union _Storage<_Up, false>
 219         {
 220           constexpr _Storage() noexcept : _M_empty() { }
 221
 222           template<typename... _Args>
 223             constexpr
 224             _Storage(in_place_t, _Args&&... __args)
 225             : _M_value(std::forward<_Args>(__args)...)
 226             { }
 227
 228           template<typename _Vp, typename... _Args>
 229             constexpr
 230             _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
 231             : _M_value(__il, std::forward<_Args>(__args)...)
 232             { }
 233
 234           // User-provided destructor is needed when _Up has non-trivial dtor.
 235           ~_Storage() { }
 236
 237           _Empty_byte _M_empty;
 238           _Up _M_value;
 239         };
 240
 241       _Storage<_Stored_type> _M_payload;
 242
 243       bool _M_engaged = false;
 244
 245       template<typename... _Args>
 246         void
 247         _M_construct(_Args&&... __args)
 248         noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 249         {
 250           ::new ((void *) std::__addressof(this->_M_payload))
 251             _Stored_type(std::forward<_Args>(__args)...);
 252           this->_M_engaged = true;
 253         }
 254
 255       constexpr void
 256       _M_destroy() noexcept
 257       {
 258         _M_engaged = false;
 259         _M_payload._M_value.~_Stored_type();
 260       }
 261
 262       // The _M_get() operations have _M_engaged as a precondition.
 263       // They exist to access the contained value with the appropriate
 264       // const-qualification, because _M_payload has had the const removed.
 265
 266       constexpr _Tp&
 267       _M_get() noexcept
 268       { return this->_M_payload._M_value; }
 269
 270       constexpr const _Tp&
 271       _M_get() const noexcept
 272       { return this->_M_payload._M_value; }
 273
 274       // _M_reset is a 'safe' operation with no precondition.
 275       constexpr void
 276       _M_reset() noexcept
 277       {
 278         if (this->_M_engaged)
 279           _M_destroy();
 280       }
 281     };
 282
 283   // Class template that manages the payload for optionals.
 284   template <typename _Tp,
 285             bool /*_HasTrivialDestructor*/ =
 286               is_trivially_destructible_v<_Tp>,
 287             bool /*_HasTrivialCopy */ =
 288               is_trivially_copy_assignable_v<_Tp>
 289               && is_trivially_copy_constructible_v<_Tp>,
 290             bool /*_HasTrivialMove */ =
 291               is_trivially_move_assignable_v<_Tp>
 292               && is_trivially_move_constructible_v<_Tp>>
 293     struct _Optional_payload;
 294
 295   // Payload for potentially-constexpr optionals (trivial copy/move/destroy).
 296   template <typename _Tp>
 297     struct _Optional_payload<_Tp, true, true, true>
 298     : _Optional_payload_base<_Tp>
 299     {
 300       using _Optional_payload_base<_Tp>::_Optional_payload_base;
 301
 302       _Optional_payload() = default;
 303     };
 304
 305   // Payload for optionals with non-trivial copy construction/assignment.
 306   template <typename _Tp>
 307     struct _Optional_payload<_Tp, true, false, true>
 308     : _Optional_payload_base<_Tp>
 309     {
 310       using _Optional_payload_base<_Tp>::_Optional_payload_base;
 311
 312       _Optional_payload() = default;
 313       ~_Optional_payload() = default;
 314       _Optional_payload(const _Optional_payload&) = default;
 315       _Optional_payload(_Optional_payload&&) = default;
 316       _Optional_payload& operator=(_Optional_payload&&) = default;
 317
 318       // Non-trivial copy assignment.
 319       constexpr
 320       _Optional_payload&
 321       operator=(const _Optional_payload& __other)
 322       {
 323         this->_M_copy_assign(__other);
 324         return *this;
 325       }
 326     };
 327
 328   // Payload for optionals with non-trivial move construction/assignment.
 329   template <typename _Tp>
 330     struct _Optional_payload<_Tp, true, true, false>
 331     : _Optional_payload_base<_Tp>
 332     {
 333       using _Optional_payload_base<_Tp>::_Optional_payload_base;
 334
 335       _Optional_payload() = default;
 336       ~_Optional_payload() = default;
 337       _Optional_payload(const _Optional_payload&) = default;
 338       _Optional_payload(_Optional_payload&&) = default;
 339       _Optional_payload& operator=(const _Optional_payload&) = default;
 340
 341       // Non-trivial move assignment.
 342       constexpr
 343       _Optional_payload&
 344       operator=(_Optional_payload&& __other)
 345       noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
 346                        is_nothrow_move_assignable<_Tp>>)
 347       {
 348         this->_M_move_assign(std::move(__other));
 349         return *this;
 350       }
 351     };
 352
 353   // Payload for optionals with non-trivial copy and move assignment.
 354   template <typename _Tp>
 355     struct _Optional_payload<_Tp, true, false, false>
 356     : _Optional_payload_base<_Tp>
 357     {
 358       using _Optional_payload_base<_Tp>::_Optional_payload_base;
 359
 360       _Optional_payload() = default;
 361       ~_Optional_payload() = default;
 362       _Optional_payload(const _Optional_payload&) = default;
 363       _Optional_payload(_Optional_payload&&) = default;
 364
 365       // Non-trivial copy assignment.
 366       constexpr
 367       _Optional_payload&
 368       operator=(const _Optional_payload& __other)
 369       {
 370         this->_M_copy_assign(__other);
 371         return *this;
 372       }
 373
 374       // Non-trivial move assignment.
 375       constexpr
 376       _Optional_payload&
 377       operator=(_Optional_payload&& __other)
 378       noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
 379                        is_nothrow_move_assignable<_Tp>>)
 380       {
 381         this->_M_move_assign(std::move(__other));
 382         return *this;
 383       }
 384     };
 385
 386   // Payload for optionals with non-trivial destructors.
 387   template <typename _Tp, bool _Copy, bool _Move>
 388     struct _Optional_payload<_Tp, false, _Copy, _Move>
 389     : _Optional_payload<_Tp, true, false, false>
 390     {
 391       // Base class implements all the constructors and assignment operators:
 392       using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
 393       _Optional_payload() = default;
 394       _Optional_payload(const _Optional_payload&) = default;
 395       _Optional_payload(_Optional_payload&&) = default;
 396       _Optional_payload& operator=(const _Optional_payload&) = default;
 397       _Optional_payload& operator=(_Optional_payload&&) = default;
 398
 399       // Destructor needs to destroy the contained value:
 400       ~_Optional_payload() { this->_M_reset(); }
 401     };
 402
 403   // Common base class for _Optional_base<T> to avoid repeating these
 404   // member functions in each specialization.
 405   template<typename _Tp, typename _Dp>
 406     class _Optional_base_impl
 407     {
 408     protected:
 409       using _Stored_type = remove_const_t<_Tp>;
 410
 411       // The _M_construct operation has !_M_engaged as a precondition
 412       // while _M_destruct has _M_engaged as a precondition.
 413       template<typename... _Args>
 414         void
 415         _M_construct(_Args&&... __args)
 416         noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 417         {
 418           ::new
 419             (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
 420             _Stored_type(std::forward<_Args>(__args)...);
 421           static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
 422         }
 423
 424       void
 425       _M_destruct() noexcept
 426       { static_cast<_Dp*>(this)->_M_payload._M_destroy(); }
 427
 428       // _M_reset is a 'safe' operation with no precondition.
 429       constexpr void
 430       _M_reset() noexcept
 431       { static_cast<_Dp*>(this)->_M_payload._M_reset(); }
 432
 433       constexpr bool _M_is_engaged() const noexcept
 434       { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }
 435
 436       // The _M_get operations have _M_engaged as a precondition.
 437       constexpr _Tp&
 438       _M_get() noexcept
 439       {
 440         __glibcxx_assert(this->_M_is_engaged());
 441         return static_cast<_Dp*>(this)->_M_payload._M_get();
 442       }
 443
 444       constexpr const _Tp&
 445       _M_get() const noexcept
 446       {
 447         __glibcxx_assert(this->_M_is_engaged());
 448         return static_cast<const _Dp*>(this)->_M_payload._M_get();
 449       }
 450     };
 451
 452   /**
 453     * @brief Class template that provides copy/move constructors of optional.
 454     *
 455     * Such a separate base class template is necessary in order to
 456     * conditionally make copy/move constructors trivial.
 457     *
 458     * When the contained value is trivially copy/move constructible,
 459     * the copy/move constructors of _Optional_base will invoke the
 460     * trivial copy/move constructor of _Optional_payload. Otherwise,
 461     * they will invoke _Optional_payload(bool, const _Optional_payload&)
 462     * or _Optional_payload(bool, _Optional_payload&&) to initialize
 463     * the contained value, if copying/moving an engaged optional.
 464     *
 465     * Whether the other special members are trivial is determined by the
 466     * _Optional_payload<_Tp> specialization used for the _M_payload member.
 467     *
 468     * @see optional, _Enable_special_members
 469     */
 470   template<typename _Tp,
 471            bool = is_trivially_copy_constructible_v<_Tp>,
 472            bool = is_trivially_move_constructible_v<_Tp>>
 473     struct _Optional_base
 474     : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
 475     {
 476       // Constructors for disengaged optionals.
 477       constexpr _Optional_base() = default;
 478
 479       // Constructors for engaged optionals.
 480       template<typename... _Args,
 481                enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 482         constexpr explicit
 483         _Optional_base(in_place_t, _Args&&... __args)
 484         : _M_payload(in_place, std::forward<_Args>(__args)...)
 485         { }
 486
 487       template<typename _Up, typename... _Args,
 488                enable_if_t<is_constructible_v<_Tp,
 489                                               initializer_list<_Up>&,
 490                                               _Args...>, bool> = false>
 491         constexpr explicit
 492         _Optional_base(in_place_t,
 493                        initializer_list<_Up> __il,
 494                        _Args&&... __args)
 495         : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 496         { }
 497
 498       // Copy and move constructors.
 499       constexpr
 500       _Optional_base(const _Optional_base& __other)
 501       : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
 502       { }
 503
 504       constexpr
 505       _Optional_base(_Optional_base&& __other)
 506       noexcept(is_nothrow_move_constructible_v<_Tp>)
 507       : _M_payload(__other._M_payload._M_engaged,
 508                    std::move(__other._M_payload))
 509       { }
 510
 511       // Assignment operators.
 512       _Optional_base& operator=(const _Optional_base&) = default;
 513       _Optional_base& operator=(_Optional_base&&) = default;
 514
 515       _Optional_payload<_Tp> _M_payload;
 516     };
 517
 518   template<typename _Tp>
 519     struct _Optional_base<_Tp, false, true>
 520     : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
 521     {
 522       // Constructors for disengaged optionals.
 523       constexpr _Optional_base() = default;
 524
 525       // Constructors for engaged optionals.
 526       template<typename... _Args,
 527                enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 528         constexpr explicit
 529         _Optional_base(in_place_t, _Args&&... __args)
 530         : _M_payload(in_place, std::forward<_Args>(__args)...)
 531         { }
 532
 533       template<typename _Up, typename... _Args,
 534                enable_if_t<is_constructible_v<_Tp,
 535                                               initializer_list<_Up>&,
 536                                               _Args...>, bool> = false>
 537         constexpr explicit
 538         _Optional_base(in_place_t,
 539                        initializer_list<_Up> __il,
 540                        _Args... __args)
 541         : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 542         { }
 543
 544       // Copy and move constructors.
 545       constexpr _Optional_base(const _Optional_base& __other)
 546       : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
 547       { }
 548
 549       constexpr _Optional_base(_Optional_base&& __other) = default;
 550
 551       // Assignment operators.
 552       _Optional_base& operator=(const _Optional_base&) = default;
 553       _Optional_base& operator=(_Optional_base&&) = default;
 554
 555       _Optional_payload<_Tp> _M_payload;
 556     };
 557
 558   template<typename _Tp>
 559     struct _Optional_base<_Tp, true, false>
 560     : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
 561     {
 562       // Constructors for disengaged optionals.
 563       constexpr _Optional_base() = default;
 564
 565       // Constructors for engaged optionals.
 566       template<typename... _Args,
 567                enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 568         constexpr explicit
 569         _Optional_base(in_place_t, _Args&&... __args)
 570         : _M_payload(in_place, std::forward<_Args>(__args)...)
 571         { }
 572
 573       template<typename _Up, typename... _Args,
 574                enable_if_t<is_constructible_v<_Tp,
 575                                               initializer_list<_Up>&,
 576                                               _Args...>, bool> = false>
 577         constexpr explicit
 578         _Optional_base(in_place_t,
 579                        initializer_list<_Up> __il,
 580                        _Args&&... __args)
 581         : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 582         { }
 583
 584       // Copy and move constructors.
 585       constexpr _Optional_base(const _Optional_base& __other) = default;
 586
 587       constexpr
 588       _Optional_base(_Optional_base&& __other)
 589       noexcept(is_nothrow_move_constructible_v<_Tp>)
 590       : _M_payload(__other._M_payload._M_engaged,
 591                    std::move(__other._M_payload))
 592       { }
 593
 594       // Assignment operators.
 595       _Optional_base& operator=(const _Optional_base&) = default;
 596       _Optional_base& operator=(_Optional_base&&) = default;
 597
 598       _Optional_payload<_Tp> _M_payload;
 599     };
 600
 601   template<typename _Tp>
 602     struct _Optional_base<_Tp, true, true>
 603     : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
 604     {
 605       // Constructors for disengaged optionals.
 606       constexpr _Optional_base() = default;
 607
 608       // Constructors for engaged optionals.
 609       template<typename... _Args,
 610                enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 611         constexpr explicit
 612         _Optional_base(in_place_t, _Args&&... __args)
 613         : _M_payload(in_place, std::forward<_Args>(__args)...)
 614         { }
 615
 616       template<typename _Up, typename... _Args,
 617                enable_if_t<is_constructible_v<_Tp,
 618                                               initializer_list<_Up>&,
 619                                               _Args...>, bool> = false>
 620         constexpr explicit
 621         _Optional_base(in_place_t,
 622                        initializer_list<_Up> __il,
 623                        _Args&&... __args)
 624         : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 625         { }
 626
 627       // Copy and move constructors.
 628       constexpr _Optional_base(const _Optional_base& __other) = default;
 629       constexpr _Optional_base(_Optional_base&& __other) = default;
 630
 631       // Assignment operators.
 632       _Optional_base& operator=(const _Optional_base&) = default;
 633       _Optional_base& operator=(_Optional_base&&) = default;
 634
 635       _Optional_payload<_Tp> _M_payload;
 636     };
 637
 638   template<typename _Tp>
 639   class optional;
 640
 641   template<typename _Tp, typename _Up>
 642     using __converts_from_optional =
 643       __or_<is_constructible<_Tp, const optional<_Up>&>,
 644             is_constructible<_Tp, optional<_Up>&>,
 645             is_constructible<_Tp, const optional<_Up>&&>,
 646             is_constructible<_Tp, optional<_Up>&&>,
 647             is_convertible<const optional<_Up>&, _Tp>,
 648             is_convertible<optional<_Up>&, _Tp>,
 649             is_convertible<const optional<_Up>&&, _Tp>,
 650             is_convertible<optional<_Up>&&, _Tp>>;
 651
 652   template<typename _Tp, typename _Up>
 653     using __assigns_from_optional =
 654       __or_<is_assignable<_Tp&, const optional<_Up>&>,
 655             is_assignable<_Tp&, optional<_Up>&>,
 656             is_assignable<_Tp&, const optional<_Up>&&>,
 657             is_assignable<_Tp&, optional<_Up>&&>>;
 658
 659   /**
 660     * @brief Class template for optional values.
 661     */
 662   template<typename _Tp>
 663     class optional
 664     : private _Optional_base<_Tp>,
 665       private _Enable_copy_move<
 666         // Copy constructor.
 667         is_copy_constructible_v<_Tp>,
 668         // Copy assignment.
 669         __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,
 670         // Move constructor.
 671         is_move_constructible_v<_Tp>,
 672         // Move assignment.
 673         __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,
 674         // Unique tag type.
 675         optional<_Tp>>
 676     {
 677       static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
 678       static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
 679       static_assert(!is_reference_v<_Tp>);
 680
 681     private:
 682       using _Base = _Optional_base<_Tp>;
 683
 684       // SFINAE helpers
 685       template<typename _Up>
 686         using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
 687       template<typename _Up>
 688         using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
 689       template<typename... _Cond>
 690         using _Requires = enable_if_t<__and_v<_Cond...>, bool>;
 691
 692     public:
 693       using value_type = _Tp;
 694
 695       constexpr optional() noexcept { }
 696
 697       constexpr optional(nullopt_t) noexcept { }
 698
 699       // Converting constructors for engaged optionals.
 700       template<typename _Up = _Tp,
 701                _Requires<__not_self<_Up>, __not_tag<_Up>,
 702                          is_constructible<_Tp, _Up>,
 703                          is_convertible<_Up, _Tp>> = true>
 704         constexpr
 705         optional(_Up&& __t)
 706         noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 707         : _Base(std::in_place, std::forward<_Up>(__t)) { }
 708
 709       template<typename _Up = _Tp,
 710                _Requires<__not_self<_Up>, __not_tag<_Up>,
 711                          is_constructible<_Tp, _Up>,
 712                          __not_<is_convertible<_Up, _Tp>>> = false>
 713         explicit constexpr
 714         optional(_Up&& __t)
 715         noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 716         : _Base(std::in_place, std::forward<_Up>(__t)) { }
 717
 718       template<typename _Up,
 719                _Requires<__not_<is_same<_Tp, _Up>>,
 720                          is_constructible<_Tp, const _Up&>,
 721                          is_convertible<const _Up&, _Tp>,
 722                          __not_<__converts_from_optional<_Tp, _Up>>> = true>
 723         constexpr
 724         optional(const optional<_Up>& __t)
 725         noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 726         {
 727           if (__t)
 728             emplace(*__t);
 729         }
 730
 731       template<typename _Up,
 732                _Requires<__not_<is_same<_Tp, _Up>>,
 733                          is_constructible<_Tp, const _Up&>,
 734                          __not_<is_convertible<const _Up&, _Tp>>,
 735                          __not_<__converts_from_optional<_Tp, _Up>>> = false>
 736         explicit constexpr
 737         optional(const optional<_Up>& __t)
 738         noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 739         {
 740           if (__t)
 741             emplace(*__t);
 742         }
 743
 744       template<typename _Up,
 745                _Requires<__not_<is_same<_Tp, _Up>>,
 746                          is_constructible<_Tp, _Up>,
 747                          is_convertible<_Up, _Tp>,
 748                          __not_<__converts_from_optional<_Tp, _Up>>> = true>
 749         constexpr
 750         optional(optional<_Up>&& __t)
 751         noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 752         {
 753           if (__t)
 754             emplace(std::move(*__t));
 755         }
 756
 757       template<typename _Up,
 758                _Requires<__not_<is_same<_Tp, _Up>>,
 759                          is_constructible<_Tp, _Up>,
 760                          __not_<is_convertible<_Up, _Tp>>,
 761                          __not_<__converts_from_optional<_Tp, _Up>>> = false>
 762         explicit constexpr
 763         optional(optional<_Up>&& __t)
 764         noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 765         {
 766           if (__t)
 767             emplace(std::move(*__t));
 768         }
 769
 770       template<typename... _Args,
 771                _Requires<is_constructible<_Tp, _Args...>> = false>
 772         explicit constexpr
 773         optional(in_place_t, _Args&&... __args)
 774         noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 775         : _Base(std::in_place, std::forward<_Args>(__args)...) { }
 776
 777       template<typename _Up, typename... _Args,
 778                _Requires<is_constructible<_Tp,
 779                                           initializer_list<_Up>&,
 780                                           _Args...>> = false>
 781         explicit constexpr
 782         optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
 783         noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
 784                                             _Args...>)
 785         : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
 786
 787
 788       // Assignment operators.
 789       optional&
 790       operator=(nullopt_t) noexcept
 791       {
 792         this->_M_reset();
 793         return *this;
 794       }
 795
 796       template<typename _Up = _Tp>
 797         enable_if_t<__and_v<__not_self<_Up>,
 798                             __not_<__and_<is_scalar<_Tp>,
 799                                           is_same<_Tp, decay_t<_Up>>>>,
 800                             is_constructible<_Tp, _Up>,
 801                             is_assignable<_Tp&, _Up>>,
 802                     optional&>
 803         operator=(_Up&& __u)
 804         noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
 805                          is_nothrow_assignable<_Tp&, _Up>>)
 806         {
 807           if (this->_M_is_engaged())
 808             this->_M_get() = std::forward<_Up>(__u);
 809           else
 810             this->_M_construct(std::forward<_Up>(__u));
 811
 812           return *this;
 813         }
 814
 815       template<typename _Up>
 816         enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
 817                             is_constructible<_Tp, const _Up&>,
 818                             is_assignable<_Tp&, _Up>,
 819                             __not_<__converts_from_optional<_Tp, _Up>>,
 820                             __not_<__assigns_from_optional<_Tp, _Up>>>,
 821                     optional&>
 822         operator=(const optional<_Up>& __u)
 823         noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
 824                          is_nothrow_assignable<_Tp&, const _Up&>>)
 825         {
 826           if (__u)
 827             {
 828               if (this->_M_is_engaged())
 829                 this->_M_get() = *__u;
 830               else
 831                 this->_M_construct(*__u);
 832             }
 833           else
 834             {
 835               this->_M_reset();
 836             }
 837           return *this;
 838         }
 839
 840       template<typename _Up>
 841         enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
 842                             is_constructible<_Tp, _Up>,
 843                             is_assignable<_Tp&, _Up>,
 844                             __not_<__converts_from_optional<_Tp, _Up>>,
 845                             __not_<__assigns_from_optional<_Tp, _Up>>>,
 846                     optional&>
 847         operator=(optional<_Up>&& __u)
 848         noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
 849                          is_nothrow_assignable<_Tp&, _Up>>)
 850         {
 851           if (__u)
 852             {
 853               if (this->_M_is_engaged())
 854                 this->_M_get() = std::move(*__u);
 855               else
 856                 this->_M_construct(std::move(*__u));
 857             }
 858           else
 859             {
 860               this->_M_reset();
 861             }
 862
 863           return *this;
 864         }
 865
 866       template<typename... _Args>
 867         enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
 868         emplace(_Args&&... __args)
 869         noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 870         {
 871           this->_M_reset();
 872           this->_M_construct(std::forward<_Args>(__args)...);
 873           return this->_M_get();
 874         }
 875
 876       template<typename _Up, typename... _Args>
 877         enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
 878                     _Tp&>
 879         emplace(initializer_list<_Up> __il, _Args&&... __args)
 880         noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
 881                                             _Args...>)
 882         {
 883           this->_M_reset();
 884           this->_M_construct(__il, std::forward<_Args>(__args)...);
 885           return this->_M_get();
 886         }
 887
 888       // Destructor is implicit, implemented in _Optional_base.
 889
 890       // Swap.
 891       void
 892       swap(optional& __other)
 893       noexcept(is_nothrow_move_constructible_v<_Tp>
 894                && is_nothrow_swappable_v<_Tp>)
 895       {
 896         using std::swap;
 897
 898         if (this->_M_is_engaged() && __other._M_is_engaged())
 899           swap(this->_M_get(), __other._M_get());
 900         else if (this->_M_is_engaged())
 901           {
 902             __other._M_construct(std::move(this->_M_get()));
 903             this->_M_destruct();
 904           }
 905         else if (__other._M_is_engaged())
 906           {
 907             this->_M_construct(std::move(__other._M_get()));
 908             __other._M_destruct();
 909           }
 910       }
 911
 912       // Observers.
 913       constexpr const _Tp*
 914       operator->() const noexcept
 915       { return std::__addressof(this->_M_get()); }
 916
 917       constexpr _Tp*
 918       operator->() noexcept
 919       { return std::__addressof(this->_M_get()); }
 920
 921       constexpr const _Tp&
 922       operator*() const& noexcept
 923       { return this->_M_get(); }
 924
 925       constexpr _Tp&
 926       operator*()& noexcept
 927       { return this->_M_get(); }
 928
 929       constexpr _Tp&&
 930       operator*()&& noexcept
 931       { return std::move(this->_M_get()); }
 932
 933       constexpr const _Tp&&
 934       operator*() const&& noexcept
 935       { return std::move(this->_M_get()); }
 936
 937       constexpr explicit operator bool() const noexcept
 938       { return this->_M_is_engaged(); }
 939
 940       constexpr bool has_value() const noexcept
 941       { return this->_M_is_engaged(); }
 942
 943       constexpr const _Tp&
 944       value() const&
 945       {
 946         return this->_M_is_engaged()
 947           ? this->_M_get()
 948           : (__throw_bad_optional_access(), this->_M_get());
 949       }
 950
 951       constexpr _Tp&
 952       value()&
 953       {
 954         return this->_M_is_engaged()
 955           ? this->_M_get()
 956           : (__throw_bad_optional_access(), this->_M_get());
 957       }
 958
 959       constexpr _Tp&&
 960       value()&&
 961       {
 962         return this->_M_is_engaged()
 963           ? std::move(this->_M_get())
 964           : (__throw_bad_optional_access(), std::move(this->_M_get()));
 965       }
 966
 967       constexpr const _Tp&&
 968       value() const&&
 969       {
 970         return this->_M_is_engaged()
 971           ? std::move(this->_M_get())
 972           : (__throw_bad_optional_access(), std::move(this->_M_get()));
 973       }
 974
 975       template<typename _Up>
 976         constexpr _Tp
 977         value_or(_Up&& __u) const&
 978         {
 979           static_assert(is_copy_constructible_v<_Tp>);
 980           static_assert(is_convertible_v<_Up&&, _Tp>);
 981
 982           return this->_M_is_engaged()
 983             ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u));
 984         }
 985
 986       template<typename _Up>
 987         constexpr _Tp
 988         value_or(_Up&& __u) &&
 989         {
 990           static_assert(is_move_constructible_v<_Tp>);
 991           static_assert(is_convertible_v<_Up&&, _Tp>);
 992
 993           return this->_M_is_engaged()
 994             ? std::move(this->_M_get())
 995             : static_cast<_Tp>(std::forward<_Up>(__u));
 996         }
 997
 998       void reset() noexcept { this->_M_reset(); }
 999     };
1000
1001   template<typename _Tp>
1002     using __optional_relop_t =
1003       enable_if_t<is_convertible<_Tp, bool>::value, bool>;
1004
1005   // Comparisons between optional values.
1006   template<typename _Tp, typename _Up>
1007     constexpr auto
1008     operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1009     -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
1010     {
1011       return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
1012              && (!__lhs || *__lhs == *__rhs);
1013     }
1014
1015   template<typename _Tp, typename _Up>
1016     constexpr auto
1017     operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1018     -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
1019     {
1020       return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
1021         || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
1022     }
1023
1024   template<typename _Tp, typename _Up>
1025     constexpr auto
1026     operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1027     -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
1028     {
1029       return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
1030     }
1031
1032   template<typename _Tp, typename _Up>
1033     constexpr auto
1034     operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1035     -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
1036     {
1037       return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
1038     }
1039
1040   template<typename _Tp, typename _Up>
1041     constexpr auto
1042     operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1043     -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
1044     {
1045       return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
1046     }
1047
1048   template<typename _Tp, typename _Up>
1049     constexpr auto
1050     operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1051     -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
1052     {
1053       return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
1054     }
1055
1056 #ifdef __cpp_lib_three_way_comparison
1057   template<typename _Tp, three_way_comparable_with<_Tp> _Up>
1058     constexpr compare_three_way_result_t<_Tp, _Up>
1059     operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y)
1060     {
1061       return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y);
1062     }
1063 #endif
1064
1065   // Comparisons with nullopt.
1066   template<typename _Tp>
1067     constexpr bool
1068     operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
1069     { return !__lhs; }
1070
1071 #ifdef __cpp_lib_three_way_comparison
1072   template<typename _Tp>
1073     constexpr strong_ordering
1074     operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept
1075     { return bool(__x) <=> false; }
1076 #else
1077   template<typename _Tp>
1078     constexpr bool
1079     operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
1080     { return !__rhs; }
1081
1082   template<typename _Tp>
1083     constexpr bool
1084     operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
1085     { return static_cast<bool>(__lhs); }
1086
1087   template<typename _Tp>
1088     constexpr bool
1089     operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
1090     { return static_cast<bool>(__rhs); }
1091
1092   template<typename _Tp>
1093     constexpr bool
1094     operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
1095     { return false; }
1096
1097   template<typename _Tp>
1098     constexpr bool
1099     operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
1100     { return static_cast<bool>(__rhs); }
1101
1102   template<typename _Tp>
1103     constexpr bool
1104     operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
1105     { return static_cast<bool>(__lhs); }
1106
1107   template<typename _Tp>
1108     constexpr bool
1109     operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
1110     { return false; }
1111
1112   template<typename _Tp>
1113     constexpr bool
1114     operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
1115     { return !__lhs; }
1116
1117   template<typename _Tp>
1118     constexpr bool
1119     operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
1120     { return true; }
1121
1122   template<typename _Tp>
1123     constexpr bool
1124     operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
1125     { return true; }
1126
1127   template<typename _Tp>
1128     constexpr bool
1129     operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
1130     { return !__rhs; }
1131 #endif // three-way-comparison
1132
1133   // Comparisons with value type.
1134   template<typename _Tp, typename _Up>
1135     constexpr auto
1136     operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
1137     -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
1138     { return __lhs && *__lhs == __rhs; }
1139
1140   template<typename _Tp, typename _Up>
1141     constexpr auto
1142     operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
1143     -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
1144     { return __rhs && __lhs == *__rhs; }
1145
1146   template<typename _Tp, typename _Up>
1147     constexpr auto
1148     operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
1149     -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
1150     { return !__lhs || *__lhs != __rhs; }
1151
1152   template<typename _Tp, typename _Up>
1153     constexpr auto
1154     operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
1155     -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
1156     { return !__rhs || __lhs != *__rhs; }
1157
1158   template<typename _Tp, typename _Up>
1159     constexpr auto
1160     operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
1161     -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
1162     { return !__lhs || *__lhs < __rhs; }
1163
1164   template<typename _Tp, typename _Up>
1165     constexpr auto
1166     operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
1167     -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
1168     { return __rhs && __lhs < *__rhs; }
1169
1170   template<typename _Tp, typename _Up>
1171     constexpr auto
1172     operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
1173     -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
1174     { return __lhs && *__lhs > __rhs; }
1175
1176   template<typename _Tp, typename _Up>
1177     constexpr auto
1178     operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
1179     -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
1180     { return !__rhs || __lhs > *__rhs; }
1181
1182   template<typename _Tp, typename _Up>
1183     constexpr auto
1184     operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
1185     -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
1186     { return !__lhs || *__lhs <= __rhs; }
1187
1188   template<typename _Tp, typename _Up>
1189     constexpr auto
1190     operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
1191     -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
1192     { return __rhs && __lhs <= *__rhs; }
1193
1194   template<typename _Tp, typename _Up>
1195     constexpr auto
1196     operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
1197     -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
1198     { return __lhs && *__lhs >= __rhs; }
1199
1200   template<typename _Tp, typename _Up>
1201     constexpr auto
1202     operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
1203     -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
1204     { return !__rhs || __lhs >= *__rhs; }
1205
1206 #ifdef __cpp_lib_three_way_comparison
1207   template<typename _Tp, typename _Up>
1208     constexpr compare_three_way_result_t<_Tp, _Up>
1209     operator<=>(const optional<_Tp>& __x, const _Up& __v)
1210     { return bool(__x) ? *__x <=> __v : strong_ordering::less; }
1211 #endif
1212
1213   // Swap and creation functions.
1214
1215   // _GLIBCXX_RESOLVE_LIB_DEFECTS
1216   // 2748. swappable traits for optionals
1217   template<typename _Tp>
1218     inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
1219     swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
1220     noexcept(noexcept(__lhs.swap(__rhs)))
1221     { __lhs.swap(__rhs); }
1222
1223   template<typename _Tp>
1224     enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
1225     swap(optional<_Tp>&, optional<_Tp>&) = delete;
1226
1227   template<typename _Tp>
1228     constexpr
1229     enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
1230                 optional<decay_t<_Tp>>>
1231     make_optional(_Tp&& __t)
1232     noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
1233     { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }
1234
1235   template<typename _Tp, typename... _Args>
1236     constexpr
1237     enable_if_t<is_constructible_v<_Tp, _Args...>,
1238                 optional<_Tp>>
1239     make_optional(_Args&&... __args)
1240     noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
1241     { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }
1242
1243   template<typename _Tp, typename _Up, typename... _Args>
1244     constexpr
1245     enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
1246                 optional<_Tp>>
1247     make_optional(initializer_list<_Up> __il, _Args&&... __args)
1248     noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
1249     { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }
1250
1251   // Hash.
1252
1253   template<typename _Tp, typename _Up = remove_const_t<_Tp>,
1254            bool = __poison_hash<_Up>::__enable_hash_call>
1255     struct __optional_hash_call_base
1256     {
1257       size_t
1258       operator()(const optional<_Tp>& __t) const
1259       noexcept(noexcept(hash<_Up>{}(*__t)))
1260       {
1261         // We pick an arbitrary hash for disengaged optionals which hopefully
1262         // usual values of _Tp won't typically hash to.
1263         constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
1264         return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
1265       }
1266     };
1267
1268   template<typename _Tp, typename _Up>
1269     struct __optional_hash_call_base<_Tp, _Up, false> {};
1270
1271   template<typename _Tp>
1272     struct hash<optional<_Tp>>
1273     : private __poison_hash<remove_const_t<_Tp>>,
1274       public __optional_hash_call_base<_Tp>
1275     {
1276       using result_type [[__deprecated__]] = size_t;
1277       using argument_type [[__deprecated__]] = optional<_Tp>;
1278     };
1279
1280   template<typename _Tp>
1281     struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
1282     { };
1283
1284   /// @}
1285
1286 #if __cpp_deduction_guides >= 201606
1287   template <typename _Tp> optional(_Tp) -> optional<_Tp>;
1288 #endif
1289
1290 _GLIBCXX_END_NAMESPACE_VERSION
1291 } // namespace std
1292
1293 #endif // C++17
1294
1295 #endif // _GLIBCXX_OPTIONAL