src/base/3rdparty/expected.hpp

   1 // This version targets C++11 and later.
   2 //
   3 // Copyright (C) 2016-2020 Martin Moene.
   4 //
   5 // Distributed under the Boost Software License, Version 1.0.
   6 // (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 //
   8 // expected lite is based on:
   9 //   A proposal to add a utility class to represent expected monad
  10 //   by Vicente J. Botet Escriba and Pierre Talbot. http:://wg21.link/p0323
  11
  12 #ifndef NONSTD_EXPECTED_LITE_HPP
  13 #define NONSTD_EXPECTED_LITE_HPP
  14
  15 #define expected_lite_MAJOR  0
  16 #define expected_lite_MINOR  6
  17 #define expected_lite_PATCH  3
  18
  19 #define expected_lite_VERSION  expected_STRINGIFY(expected_lite_MAJOR) "." expected_STRINGIFY(expected_lite_MINOR) "." expected_STRINGIFY(expected_lite_PATCH)
  20
  21 #define expected_STRINGIFY(  x )  expected_STRINGIFY_( x )
  22 #define expected_STRINGIFY_( x )  #x
  23
  24 // expected-lite configuration:
  25
  26 #define nsel_EXPECTED_DEFAULT  0
  27 #define nsel_EXPECTED_NONSTD   1
  28 #define nsel_EXPECTED_STD      2
  29
  30 // tweak header support:
  31
  32 #ifdef __has_include
  33 # if __has_include(<nonstd/expected.tweak.hpp>)
  34 #  include <nonstd/expected.tweak.hpp>
  35 # endif
  36 #define expected_HAVE_TWEAK_HEADER  1
  37 #else
  38 #define expected_HAVE_TWEAK_HEADER  0
  39 //# pragma message("expected.hpp: Note: Tweak header not supported.")
  40 #endif
  41
  42 // expected selection and configuration:
  43
  44 #if !defined( nsel_CONFIG_SELECT_EXPECTED )
  45 # define nsel_CONFIG_SELECT_EXPECTED  ( nsel_HAVE_STD_EXPECTED ? nsel_EXPECTED_STD : nsel_EXPECTED_NONSTD )
  46 #endif
  47
  48 // Proposal revisions:
  49 //
  50 // DXXXXR0: --
  51 // N4015  : -2 (2014-05-26)
  52 // N4109  : -1 (2014-06-29)
  53 // P0323R0:  0 (2016-05-28)
  54 // P0323R1:  1 (2016-10-12)
  55 // -------:
  56 // P0323R2:  2 (2017-06-15)
  57 // P0323R3:  3 (2017-10-15)
  58 // P0323R4:  4 (2017-11-26)
  59 // P0323R5:  5 (2018-02-08)
  60 // P0323R6:  6 (2018-04-02)
  61 // P0323R7:  7 (2018-06-22) *
  62 //
  63 // expected-lite uses 2 and higher
  64
  65 #ifndef  nsel_P0323R
  66 # define nsel_P0323R  7
  67 #endif
  68
  69 // Control presence of C++ exception handling (try and auto discover):
  70
  71 #ifndef nsel_CONFIG_NO_EXCEPTIONS
  72 # if defined(_MSC_VER)
  73 #  include <cstddef>    // for _HAS_EXCEPTIONS
  74 # endif
  75 # if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS)
  76 #  define nsel_CONFIG_NO_EXCEPTIONS  0
  77 # else
  78 #  define nsel_CONFIG_NO_EXCEPTIONS  1
  79 # endif
  80 #endif
  81
  82 // at default use SEH with MSVC for no C++ exceptions
  83
  84 #ifndef  nsel_CONFIG_NO_EXCEPTIONS_SEH
  85 # define nsel_CONFIG_NO_EXCEPTIONS_SEH  ( nsel_CONFIG_NO_EXCEPTIONS && _MSC_VER )
  86 #endif
  87
  88 // C++ language version detection (C++23 is speculative):
  89 // Note: VC14.0/1900 (VS2015) lacks too much from C++14.
  90
  91 #ifndef   nsel_CPLUSPLUS
  92 # if defined(_MSVC_LANG ) && !defined(__clang__)
  93 #  define nsel_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
  94 # else
  95 #  define nsel_CPLUSPLUS  __cplusplus
  96 # endif
  97 #endif
  98
  99 #define nsel_CPP98_OR_GREATER  ( nsel_CPLUSPLUS >= 199711L )
 100 #define nsel_CPP11_OR_GREATER  ( nsel_CPLUSPLUS >= 201103L )
 101 #define nsel_CPP14_OR_GREATER  ( nsel_CPLUSPLUS >= 201402L )
 102 #define nsel_CPP17_OR_GREATER  ( nsel_CPLUSPLUS >= 201703L )
 103 #define nsel_CPP20_OR_GREATER  ( nsel_CPLUSPLUS >= 202002L )
 104 #define nsel_CPP23_OR_GREATER  ( nsel_CPLUSPLUS >= 202300L )
 105
 106 // Use C++23 std::expected if available and requested:
 107
 108 #if nsel_CPP23_OR_GREATER && defined(__has_include )
 109 # if __has_include( <expected> )
 110 #  define nsel_HAVE_STD_EXPECTED  1
 111 # else
 112 #  define nsel_HAVE_STD_EXPECTED  0
 113 # endif
 114 #else
 115 # define  nsel_HAVE_STD_EXPECTED  0
 116 #endif
 117
 118 #define  nsel_USES_STD_EXPECTED  ( (nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_STD) || ((nsel_CONFIG_SELECT_EXPECTED == nsel_EXPECTED_DEFAULT) && nsel_HAVE_STD_EXPECTED) )
 119
 120 //
 121 // in_place: code duplicated in any-lite, expected-lite, expected-lite, value-ptr-lite, variant-lite:
 122 //
 123
 124 #ifndef nonstd_lite_HAVE_IN_PLACE_TYPES
 125 #define nonstd_lite_HAVE_IN_PLACE_TYPES  1
 126
 127 // C++17 std::in_place in <utility>:
 128
 129 #if nsel_CPP17_OR_GREATER
 130
 131 #include <utility>
 132
 133 namespace nonstd {
 134
 135 using std::in_place;
 136 using std::in_place_type;
 137 using std::in_place_index;
 138 using std::in_place_t;
 139 using std::in_place_type_t;
 140 using std::in_place_index_t;
 141
 142 #define nonstd_lite_in_place_t(      T)  std::in_place_t
 143 #define nonstd_lite_in_place_type_t( T)  std::in_place_type_t<T>
 144 #define nonstd_lite_in_place_index_t(K)  std::in_place_index_t<K>
 145
 146 #define nonstd_lite_in_place(      T)    std::in_place_t{}
 147 #define nonstd_lite_in_place_type( T)    std::in_place_type_t<T>{}
 148 #define nonstd_lite_in_place_index(K)    std::in_place_index_t<K>{}
 149
 150 } // namespace nonstd
 151
 152 #else // nsel_CPP17_OR_GREATER
 153
 154 #include <cstddef>
 155
 156 namespace nonstd {
 157 namespace detail {
 158
 159 template< class T >
 160 struct in_place_type_tag {};
 161
 162 template< std::size_t K >
 163 struct in_place_index_tag {};
 164
 165 } // namespace detail
 166
 167 struct in_place_t {};
 168
 169 template< class T >
 170 inline in_place_t in_place( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
 171 {
 172     return in_place_t();
 173 }
 174
 175 template< std::size_t K >
 176 inline in_place_t in_place( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
 177 {
 178     return in_place_t();
 179 }
 180
 181 template< class T >
 182 inline in_place_t in_place_type( detail::in_place_type_tag<T> = detail::in_place_type_tag<T>() )
 183 {
 184     return in_place_t();
 185 }
 186
 187 template< std::size_t K >
 188 inline in_place_t in_place_index( detail::in_place_index_tag<K> = detail::in_place_index_tag<K>() )
 189 {
 190     return in_place_t();
 191 }
 192
 193 // mimic templated typedef:
 194
 195 #define nonstd_lite_in_place_t(      T)  nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T>  )
 196 #define nonstd_lite_in_place_type_t( T)  nonstd::in_place_t(&)( nonstd::detail::in_place_type_tag<T>  )
 197 #define nonstd_lite_in_place_index_t(K)  nonstd::in_place_t(&)( nonstd::detail::in_place_index_tag<K> )
 198
 199 #define nonstd_lite_in_place(      T)    nonstd::in_place_type<T>
 200 #define nonstd_lite_in_place_type( T)    nonstd::in_place_type<T>
 201 #define nonstd_lite_in_place_index(K)    nonstd::in_place_index<K>
 202
 203 } // namespace nonstd
 204
 205 #endif // nsel_CPP17_OR_GREATER
 206 #endif // nonstd_lite_HAVE_IN_PLACE_TYPES
 207
 208 //
 209 // Using std::expected:
 210 //
 211
 212 #if nsel_USES_STD_EXPECTED
 213
 214 #include <expected>
 215
 216 namespace nonstd {
 217
 218     using std::expected;
 219 //  ...
 220 }
 221
 222 #else // nsel_USES_STD_EXPECTED
 223
 224 #include <cassert>
 225 #include <exception>
 226 #include <functional>
 227 #include <initializer_list>
 228 #include <memory>
 229 #include <new>
 230 #include <system_error>
 231 #include <type_traits>
 232 #include <utility>
 233
 234 // additional includes:
 235
 236 #if nsel_CONFIG_NO_EXCEPTIONS
 237 # if nsel_CONFIG_NO_EXCEPTIONS_SEH
 238 #  include <windows.h>   // for ExceptionCodes
 239 # else
 240 // already included: <cassert>
 241 # endif
 242 #else
 243 # include <stdexcept>
 244 #endif
 245
 246 // C++ feature usage:
 247
 248 #if nsel_CPP11_OR_GREATER
 249 # define nsel_constexpr  constexpr
 250 #else
 251 # define nsel_constexpr  /*constexpr*/
 252 #endif
 253
 254 #if nsel_CPP14_OR_GREATER
 255 # define nsel_constexpr14 constexpr
 256 #else
 257 # define nsel_constexpr14 /*constexpr*/
 258 #endif
 259
 260 #if nsel_CPP17_OR_GREATER
 261 # define nsel_inline17 inline
 262 #else
 263 # define nsel_inline17 /*inline*/
 264 #endif
 265
 266 // Compiler versions:
 267 //
 268 // MSVC++  6.0  _MSC_VER == 1200  nsel_COMPILER_MSVC_VERSION ==  60  (Visual Studio 6.0)
 269 // MSVC++  7.0  _MSC_VER == 1300  nsel_COMPILER_MSVC_VERSION ==  70  (Visual Studio .NET 2002)
 270 // MSVC++  7.1  _MSC_VER == 1310  nsel_COMPILER_MSVC_VERSION ==  71  (Visual Studio .NET 2003)
 271 // MSVC++  8.0  _MSC_VER == 1400  nsel_COMPILER_MSVC_VERSION ==  80  (Visual Studio 2005)
 272 // MSVC++  9.0  _MSC_VER == 1500  nsel_COMPILER_MSVC_VERSION ==  90  (Visual Studio 2008)
 273 // MSVC++ 10.0  _MSC_VER == 1600  nsel_COMPILER_MSVC_VERSION == 100  (Visual Studio 2010)
 274 // MSVC++ 11.0  _MSC_VER == 1700  nsel_COMPILER_MSVC_VERSION == 110  (Visual Studio 2012)
 275 // MSVC++ 12.0  _MSC_VER == 1800  nsel_COMPILER_MSVC_VERSION == 120  (Visual Studio 2013)
 276 // MSVC++ 14.0  _MSC_VER == 1900  nsel_COMPILER_MSVC_VERSION == 140  (Visual Studio 2015)
 277 // MSVC++ 14.1  _MSC_VER >= 1910  nsel_COMPILER_MSVC_VERSION == 141  (Visual Studio 2017)
 278 // MSVC++ 14.2  _MSC_VER >= 1920  nsel_COMPILER_MSVC_VERSION == 142  (Visual Studio 2019)
 279
 280 #if defined(_MSC_VER) && !defined(__clang__)
 281 # define nsel_COMPILER_MSVC_VER      (_MSC_VER )
 282 # define nsel_COMPILER_MSVC_VERSION  (_MSC_VER / 10 - 10 * ( 5 + (_MSC_VER < 1900)) )
 283 #else
 284 # define nsel_COMPILER_MSVC_VER      0
 285 # define nsel_COMPILER_MSVC_VERSION  0
 286 #endif
 287
 288 #define nsel_COMPILER_VERSION( major, minor, patch )  ( 10 * ( 10 * (major) + (minor) ) + (patch) )
 289
 290 #if defined(__clang__)
 291 # define nsel_COMPILER_CLANG_VERSION  nsel_COMPILER_VERSION(__clang_major__, __clang_minor__, __clang_patchlevel__)
 292 #else
 293 # define nsel_COMPILER_CLANG_VERSION  0
 294 #endif
 295
 296 #if defined(__GNUC__) && !defined(__clang__)
 297 # define nsel_COMPILER_GNUC_VERSION  nsel_COMPILER_VERSION(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 298 #else
 299 # define nsel_COMPILER_GNUC_VERSION  0
 300 #endif
 301
 302 // half-open range [lo..hi):
 303 //#define nsel_BETWEEN( v, lo, hi ) ( (lo) <= (v) && (v) < (hi) )
 304
 305 // Method enabling
 306
 307 #define nsel_REQUIRES_0(...) \
 308     template< bool B = (__VA_ARGS__), typename std::enable_if<B, int>::type = 0 >
 309
 310 #define nsel_REQUIRES_T(...) \
 311     , typename std::enable_if< (__VA_ARGS__), int >::type = 0
 312
 313 #define nsel_REQUIRES_R(R, ...) \
 314     typename std::enable_if< (__VA_ARGS__), R>::type
 315
 316 #define nsel_REQUIRES_A(...) \
 317     , typename std::enable_if< (__VA_ARGS__), void*>::type = nullptr
 318
 319 // Presence of language and library features:
 320
 321 #ifdef _HAS_CPP0X
 322 # define nsel_HAS_CPP0X  _HAS_CPP0X
 323 #else
 324 # define nsel_HAS_CPP0X  0
 325 #endif
 326
 327 //#define nsel_CPP11_140  (nsel_CPP11_OR_GREATER || nsel_COMPILER_MSVC_VER >= 1900)
 328
 329 // Clang, GNUC, MSVC warning suppression macros:
 330
 331 #ifdef __clang__
 332 # pragma clang diagnostic push
 333 #elif defined  __GNUC__
 334 # pragma  GCC  diagnostic push
 335 #endif // __clang__
 336
 337 #if nsel_COMPILER_MSVC_VERSION >= 140
 338 # pragma warning( push )
 339 # define nsel_DISABLE_MSVC_WARNINGS(codes)  __pragma( warning(disable: codes) )
 340 #else
 341 # define nsel_DISABLE_MSVC_WARNINGS(codes)
 342 #endif
 343
 344 #ifdef __clang__
 345 # define nsel_RESTORE_WARNINGS()  _Pragma("clang diagnostic pop")
 346 #elif defined __GNUC__
 347 # define nsel_RESTORE_WARNINGS()  _Pragma("GCC diagnostic pop")
 348 #elif nsel_COMPILER_MSVC_VERSION >= 140
 349 # define nsel_RESTORE_WARNINGS()  __pragma( warning( pop ) )
 350 #else
 351 # define nsel_RESTORE_WARNINGS()
 352 #endif
 353
 354 // Suppress the following MSVC (GSL) warnings:
 355 // - C26409: Avoid calling new and delete explicitly, use std::make_unique<T> instead (r.11)
 356
 357 nsel_DISABLE_MSVC_WARNINGS( 26409 )
 358
 359 //
 360 // expected:
 361 //
 362
 363 namespace nonstd { namespace expected_lite {
 364
 365 // type traits C++17:
 366
 367 namespace std17 {
 368
 369 #if nsel_CPP17_OR_GREATER
 370
 371 using std::conjunction;
 372 using std::is_swappable;
 373 using std::is_nothrow_swappable;
 374
 375 #else // nsel_CPP17_OR_GREATER
 376
 377 namespace detail {
 378
 379 using std::swap;
 380
 381 struct is_swappable
 382 {
 383     template< typename T, typename = decltype( swap( std::declval<T&>(), std::declval<T&>() ) ) >
 384     static std::true_type test( int /* unused */);
 385
 386     template< typename >
 387     static std::false_type test(...);
 388 };
 389
 390 struct is_nothrow_swappable
 391 {
 392     // wrap noexcept(expr) in separate function as work-around for VC140 (VS2015):
 393
 394     template< typename T >
 395     static constexpr bool satisfies()
 396     {
 397         return noexcept( swap( std::declval<T&>(), std::declval<T&>() ) );
 398     }
 399
 400     template< typename T >
 401     static auto test( int ) -> std::integral_constant<bool, satisfies<T>()>{}
 402
 403     template< typename >
 404     static auto test(...) -> std::false_type;
 405 };
 406 } // namespace detail
 407
 408 // is [nothrow] swappable:
 409
 410 template< typename T >
 411 struct is_swappable : decltype( detail::is_swappable::test<T>(0) ){};
 412
 413 template< typename T >
 414 struct is_nothrow_swappable : decltype( detail::is_nothrow_swappable::test<T>(0) ){};
 415
 416 // conjunction:
 417
 418 template< typename... > struct conjunction : std::true_type{};
 419 template< typename B1 > struct conjunction<B1> : B1{};
 420
 421 template< typename B1, typename... Bn >
 422 struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type{};
 423
 424 #endif // nsel_CPP17_OR_GREATER
 425
 426 } // namespace std17
 427
 428 // type traits C++20:
 429
 430 namespace std20 {
 431
 432 #if defined(__cpp_lib_remove_cvref)
 433
 434 using std::remove_cvref;
 435
 436 #else
 437
 438 template< typename T >
 439 struct remove_cvref
 440 {
 441     typedef typename std::remove_cv< typename std::remove_reference<T>::type >::type type;
 442 };
 443
 444 #endif
 445
 446 } // namespace std20
 447
 448 // forward declaration:
 449
 450 template< typename T, typename E >
 451 class expected;
 452
 453 namespace detail {
 454
 455 /// discriminated union to hold value or 'error'.
 456
 457 template< typename T, typename E >
 458 class storage_t_impl
 459 {
 460     template< typename, typename > friend class nonstd::expected_lite::expected;
 461
 462 public:
 463     using value_type = T;
 464     using error_type = E;
 465
 466     // no-op construction
 467     storage_t_impl() {}
 468     ~storage_t_impl() {}
 469
 470     explicit storage_t_impl( bool has_value )
 471         : m_has_value( has_value )
 472     {}
 473
 474     void construct_value( value_type const & e )
 475     {
 476         new( &m_value ) value_type( e );
 477     }
 478
 479     void construct_value( value_type && e )
 480     {
 481         new( &m_value ) value_type( std::move( e ) );
 482     }
 483
 484     template< class... Args >
 485     void emplace_value( Args&&... args )
 486     {
 487         new( &m_value ) value_type( std::forward<Args>(args)...);
 488     }
 489
 490     template< class U, class... Args >
 491     void emplace_value( std::initializer_list<U> il, Args&&... args )
 492     {
 493         new( &m_value ) value_type( il, std::forward<Args>(args)... );
 494     }
 495
 496     void destruct_value()
 497     {
 498         m_value.~value_type();
 499     }
 500
 501     void construct_error( error_type const & e )
 502     {
 503         new( &m_error ) error_type( e );
 504     }
 505
 506     void construct_error( error_type && e )
 507     {
 508         new( &m_error ) error_type( std::move( e ) );
 509     }
 510
 511     template< class... Args >
 512     void emplace_error( Args&&... args )
 513     {
 514         new( &m_error ) error_type( std::forward<Args>(args)...);
 515     }
 516
 517     template< class U, class... Args >
 518     void emplace_error( std::initializer_list<U> il, Args&&... args )
 519     {
 520         new( &m_error ) error_type( il, std::forward<Args>(args)... );
 521     }
 522
 523     void destruct_error()
 524     {
 525         m_error.~error_type();
 526     }
 527
 528     constexpr value_type const & value() const &
 529     {
 530         return m_value;
 531     }
 532
 533     value_type & value() &
 534     {
 535         return m_value;
 536     }
 537
 538     constexpr value_type const && value() const &&
 539     {
 540         return std::move( m_value );
 541     }
 542
 543     nsel_constexpr14 value_type && value() &&
 544     {
 545         return std::move( m_value );
 546     }
 547
 548     value_type const * value_ptr() const
 549     {
 550         return &m_value;
 551     }
 552
 553     value_type * value_ptr()
 554     {
 555         return &m_value;
 556     }
 557
 558     error_type const & error() const &
 559     {
 560         return m_error;
 561     }
 562
 563     error_type & error() &
 564     {
 565         return m_error;
 566     }
 567
 568     constexpr error_type const && error() const &&
 569     {
 570         return std::move( m_error );
 571     }
 572
 573     nsel_constexpr14 error_type && error() &&
 574     {
 575         return std::move( m_error );
 576     }
 577
 578     bool has_value() const
 579     {
 580         return m_has_value;
 581     }
 582
 583     void set_has_value( bool v )
 584     {
 585         m_has_value = v;
 586     }
 587
 588 private:
 589     union
 590     {
 591         value_type m_value;
 592         error_type m_error;
 593     };
 594
 595     bool m_has_value = false;
 596 };
 597
 598 /// discriminated union to hold only 'error'.
 599
 600 template< typename E >
 601 struct storage_t_impl<void, E>
 602 {
 603     template< typename, typename > friend class nonstd::expected_lite::expected;
 604
 605 public:
 606     using value_type = void;
 607     using error_type = E;
 608
 609     // no-op construction
 610     storage_t_impl() {}
 611     ~storage_t_impl() {}
 612
 613     explicit storage_t_impl( bool has_value )
 614         : m_has_value( has_value )
 615     {}
 616
 617     void construct_error( error_type const & e )
 618     {
 619         new( &m_error ) error_type( e );
 620     }
 621
 622     void construct_error( error_type && e )
 623     {
 624         new( &m_error ) error_type( std::move( e ) );
 625     }
 626
 627     template< class... Args >
 628     void emplace_error( Args&&... args )
 629     {
 630         new( &m_error ) error_type( std::forward<Args>(args)...);
 631     }
 632
 633     template< class U, class... Args >
 634     void emplace_error( std::initializer_list<U> il, Args&&... args )
 635     {
 636         new( &m_error ) error_type( il, std::forward<Args>(args)... );
 637     }
 638
 639     void destruct_error()
 640     {
 641         m_error.~error_type();
 642     }
 643
 644     error_type const & error() const &
 645     {
 646         return m_error;
 647     }
 648
 649     error_type & error() &
 650     {
 651         return m_error;
 652     }
 653
 654     constexpr error_type const && error() const &&
 655     {
 656         return std::move( m_error );
 657     }
 658
 659     nsel_constexpr14 error_type && error() &&
 660     {
 661         return std::move( m_error );
 662     }
 663
 664     bool has_value() const
 665     {
 666         return m_has_value;
 667     }
 668
 669     void set_has_value( bool v )
 670     {
 671         m_has_value = v;
 672     }
 673
 674 private:
 675     union
 676     {
 677         char m_dummy;
 678         error_type m_error;
 679     };
 680
 681     bool m_has_value = false;
 682 };
 683
 684 template< typename T, typename E, bool isConstructable, bool isMoveable >
 685 class storage_t
 686 {
 687 public:
 688     storage_t() = default;
 689     ~storage_t() = default;
 690
 691     explicit storage_t( bool has_value )
 692         : storage_t_impl<T, E>( has_value )
 693     {}
 694
 695     storage_t( storage_t const & other ) = delete;
 696     storage_t( storage_t &&      other ) = delete;
 697 };
 698
 699 template< typename T, typename E >
 700 class storage_t<T, E, true, true> : public storage_t_impl<T, E>
 701 {
 702 public:
 703     storage_t() = default;
 704     ~storage_t() = default;
 705
 706     explicit storage_t( bool has_value )
 707         : storage_t_impl<T, E>( has_value )
 708     {}
 709
 710     storage_t( storage_t const & other )
 711         : storage_t_impl<T, E>( other.has_value() )
 712     {
 713         if ( this->has_value() ) this->construct_value( other.value() );
 714         else                     this->construct_error( other.error() );
 715     }
 716
 717     storage_t(storage_t && other )
 718         : storage_t_impl<T, E>( other.has_value() )
 719     {
 720         if ( this->has_value() ) this->construct_value( std::move( other.value() ) );
 721         else                     this->construct_error( std::move( other.error() ) );
 722     }
 723 };
 724
 725 template< typename E >
 726 class storage_t<void, E, true, true> : public storage_t_impl<void, E>
 727 {
 728 public:
 729     storage_t() = default;
 730     ~storage_t() = default;
 731
 732     explicit storage_t( bool has_value )
 733         : storage_t_impl<void, E>( has_value )
 734     {}
 735
 736     storage_t( storage_t const & other )
 737         : storage_t_impl<void, E>( other.has_value() )
 738     {
 739         if ( this->has_value() ) ;
 740         else                     this->construct_error( other.error() );
 741     }
 742
 743     storage_t(storage_t && other )
 744         : storage_t_impl<void, E>( other.has_value() )
 745     {
 746         if ( this->has_value() ) ;
 747         else                     this->construct_error( std::move( other.error() ) );
 748     }
 749 };
 750
 751 template< typename T, typename E >
 752 class storage_t<T, E, true, false> : public storage_t_impl<T, E>
 753 {
 754 public:
 755     storage_t() = default;
 756     ~storage_t() = default;
 757
 758     explicit storage_t( bool has_value )
 759         : storage_t_impl<T, E>( has_value )
 760     {}
 761
 762     storage_t( storage_t const & other )
 763         : storage_t_impl<T, E>(other.has_value())
 764     {
 765         if ( this->has_value() ) this->construct_value( other.value() );
 766         else                     this->construct_error( other.error() );
 767     }
 768
 769     storage_t( storage_t && other ) = delete;
 770 };
 771
 772 template< typename E >
 773 class storage_t<void, E, true, false> : public storage_t_impl<void, E>
 774 {
 775 public:
 776     storage_t() = default;
 777     ~storage_t() = default;
 778
 779     explicit storage_t( bool has_value )
 780         : storage_t_impl<void, E>( has_value )
 781     {}
 782
 783     storage_t( storage_t const & other )
 784         : storage_t_impl<void, E>(other.has_value())
 785     {
 786         if ( this->has_value() ) ;
 787         else                     this->construct_error( other.error() );
 788     }
 789
 790     storage_t( storage_t && other ) = delete;
 791 };
 792
 793 template< typename T, typename E >
 794 class storage_t<T, E, false, true> : public storage_t_impl<T, E>
 795 {
 796 public:
 797     storage_t() = default;
 798     ~storage_t() = default;
 799
 800     explicit storage_t( bool has_value )
 801         : storage_t_impl<T, E>( has_value )
 802     {}
 803
 804     storage_t( storage_t const & other ) = delete;
 805
 806     storage_t( storage_t && other )
 807         : storage_t_impl<T, E>( other.has_value() )
 808     {
 809         if ( this->has_value() ) this->construct_value( std::move( other.value() ) );
 810         else                     this->construct_error( std::move( other.error() ) );
 811     }
 812 };
 813
 814 template< typename E >
 815 class storage_t<void, E, false, true> : public storage_t_impl<void, E>
 816 {
 817 public:
 818     storage_t() = default;
 819     ~storage_t() = default;
 820
 821     explicit storage_t( bool has_value )
 822         : storage_t_impl<void, E>( has_value )
 823     {}
 824
 825     storage_t( storage_t const & other ) = delete;
 826
 827     storage_t( storage_t && other )
 828         : storage_t_impl<void, E>( other.has_value() )
 829     {
 830         if ( this->has_value() ) ;
 831         else                     this->construct_error( std::move( other.error() ) );
 832     }
 833 };
 834
 835 } // namespace detail
 836
 837 /// x.x.5 Unexpected object type; unexpected_type; C++17 and later can also use aliased type unexpected.
 838
 839 #if nsel_P0323R <= 2
 840 template< typename E = std::exception_ptr >
 841 class unexpected_type
 842 #else
 843 template< typename E >
 844 class unexpected_type
 845 #endif // nsel_P0323R
 846 {
 847 public:
 848     using error_type = E;
 849
 850     // x.x.5.2.1 Constructors
 851
 852 //  unexpected_type() = delete;
 853
 854     constexpr unexpected_type( unexpected_type const & ) = default;
 855     constexpr unexpected_type( unexpected_type && ) = default;
 856
 857     template< typename... Args
 858         nsel_REQUIRES_T(
 859             std::is_constructible<E, Args&&...>::value
 860         )
 861     >
 862     constexpr explicit unexpected_type( nonstd_lite_in_place_t(E), Args &&... args )
 863     : m_error( std::forward<Args>( args )...)
 864     {}
 865
 866     template< typename U, typename... Args
 867         nsel_REQUIRES_T(
 868             std::is_constructible<E, std::initializer_list<U>, Args&&...>::value
 869         )
 870     >
 871     constexpr explicit unexpected_type( nonstd_lite_in_place_t(E), std::initializer_list<U> il, Args &&... args )
 872     : m_error( il, std::forward<Args>( args )...)
 873     {}
 874
 875     template< typename E2
 876         nsel_REQUIRES_T(
 877             std::is_constructible<E,E2>::value
 878             && !std::is_same< typename std20::remove_cvref<E2>::type, nonstd_lite_in_place_t(E2) >::value
 879             && !std::is_same< typename std20::remove_cvref<E2>::type, unexpected_type >::value
 880         )
 881     >
 882     constexpr explicit unexpected_type( E2 && error )
 883     : m_error( std::forward<E2>( error ) )
 884     {}
 885
 886     template< typename E2
 887         nsel_REQUIRES_T(
 888             std::is_constructible<    E, E2>::value
 889             && !std::is_constructible<E, unexpected_type<E2>       &   >::value
 890             && !std::is_constructible<E, unexpected_type<E2>           >::value
 891             && !std::is_constructible<E, unexpected_type<E2> const &   >::value
 892             && !std::is_constructible<E, unexpected_type<E2> const     >::value
 893             && !std::is_convertible<     unexpected_type<E2>       &, E>::value
 894             && !std::is_convertible<     unexpected_type<E2>        , E>::value
 895             && !std::is_convertible<     unexpected_type<E2> const &, E>::value
 896             && !std::is_convertible<     unexpected_type<E2> const  , E>::value
 897             && !std::is_convertible< E2 const &, E>::value /*=> explicit */
 898         )
 899     >
 900     constexpr explicit unexpected_type( unexpected_type<E2> const & error )
 901     : m_error( E{ error.value() } )
 902     {}
 903
 904     template< typename E2
 905         nsel_REQUIRES_T(
 906             std::is_constructible<    E, E2>::value
 907             && !std::is_constructible<E, unexpected_type<E2>       &   >::value
 908             && !std::is_constructible<E, unexpected_type<E2>           >::value
 909             && !std::is_constructible<E, unexpected_type<E2> const &   >::value
 910             && !std::is_constructible<E, unexpected_type<E2> const     >::value
 911             && !std::is_convertible<     unexpected_type<E2>       &, E>::value
 912             && !std::is_convertible<     unexpected_type<E2>        , E>::value
 913             && !std::is_convertible<     unexpected_type<E2> const &, E>::value
 914             && !std::is_convertible<     unexpected_type<E2> const  , E>::value
 915             &&  std::is_convertible< E2 const &, E>::value /*=> explicit */
 916         )
 917     >
 918     constexpr /*non-explicit*/ unexpected_type( unexpected_type<E2> const & error )
 919     : m_error( error.value() )
 920     {}
 921
 922     template< typename E2
 923         nsel_REQUIRES_T(
 924             std::is_constructible<    E, E2>::value
 925             && !std::is_constructible<E, unexpected_type<E2>       &   >::value
 926             && !std::is_constructible<E, unexpected_type<E2>           >::value
 927             && !std::is_constructible<E, unexpected_type<E2> const &   >::value
 928             && !std::is_constructible<E, unexpected_type<E2> const     >::value
 929             && !std::is_convertible<     unexpected_type<E2>       &, E>::value
 930             && !std::is_convertible<     unexpected_type<E2>        , E>::value
 931             && !std::is_convertible<     unexpected_type<E2> const &, E>::value
 932             && !std::is_convertible<     unexpected_type<E2> const  , E>::value
 933             && !std::is_convertible< E2 const &, E>::value /*=> explicit */
 934         )
 935     >
 936     constexpr explicit unexpected_type( unexpected_type<E2> && error )
 937     : m_error( E{ std::move( error.value() ) } )
 938     {}
 939
 940     template< typename E2
 941         nsel_REQUIRES_T(
 942             std::is_constructible<    E, E2>::value
 943             && !std::is_constructible<E, unexpected_type<E2>       &   >::value
 944             && !std::is_constructible<E, unexpected_type<E2>           >::value
 945             && !std::is_constructible<E, unexpected_type<E2> const &   >::value
 946             && !std::is_constructible<E, unexpected_type<E2> const     >::value
 947             && !std::is_convertible<     unexpected_type<E2>       &, E>::value
 948             && !std::is_convertible<     unexpected_type<E2>        , E>::value
 949             && !std::is_convertible<     unexpected_type<E2> const &, E>::value
 950             && !std::is_convertible<     unexpected_type<E2> const  , E>::value
 951             &&  std::is_convertible< E2 const &, E>::value /*=> non-explicit */
 952         )
 953     >
 954     constexpr /*non-explicit*/ unexpected_type( unexpected_type<E2> && error )
 955     : m_error( std::move( error.value() ) )
 956     {}
 957
 958     // x.x.5.2.2 Assignment
 959
 960     nsel_constexpr14 unexpected_type& operator=( unexpected_type const & ) = default;
 961     nsel_constexpr14 unexpected_type& operator=( unexpected_type && ) = default;
 962
 963     template< typename E2 = E >
 964     nsel_constexpr14 unexpected_type & operator=( unexpected_type<E2> const & other )
 965     {
 966         unexpected_type{ other.value() }.swap( *this );
 967         return *this;
 968     }
 969
 970     template< typename E2 = E >
 971     nsel_constexpr14 unexpected_type & operator=( unexpected_type<E2> && other )
 972     {
 973         unexpected_type{ std::move( other.value() ) }.swap( *this );
 974         return *this;
 975     }
 976
 977     // x.x.5.2.3 Observers
 978
 979     nsel_constexpr14 E & value() & noexcept
 980     {
 981         return m_error;
 982     }
 983
 984     constexpr E const & value() const & noexcept
 985     {
 986         return m_error;
 987     }
 988
 989 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
 990
 991     nsel_constexpr14 E && value() && noexcept
 992     {
 993         return std::move( m_error );
 994     }
 995
 996     constexpr E const && value() const && noexcept
 997     {
 998         return std::move( m_error );
 999     }
1000
1001 #endif
1002
1003     // x.x.5.2.4 Swap
1004
1005     template< typename U=E >
1006     nsel_REQUIRES_R( void,
1007         std17::is_swappable<U>::value
1008     )
1009     swap( unexpected_type & other ) noexcept (
1010         std17::is_nothrow_swappable<U>::value
1011     )
1012     {
1013         using std::swap;
1014         swap( m_error, other.m_error );
1015     }
1016
1017     // TODO: ??? unexpected_type: in-class friend operator==, !=
1018
1019 private:
1020     error_type m_error;
1021 };
1022
1023 #if nsel_CPP17_OR_GREATER
1024
1025 /// template deduction guide:
1026
1027 template< typename E >
1028 unexpected_type( E ) -> unexpected_type< E >;
1029
1030 #endif
1031
1032 /// class unexpected_type, std::exception_ptr specialization (P0323R2)
1033
1034 #if !nsel_CONFIG_NO_EXCEPTIONS
1035 #if  nsel_P0323R <= 2
1036
1037 // TODO: Should expected be specialized for particular E types such as exception_ptr and how?
1038 //       See p0323r7 2.1. Ergonomics, http://wg21.link/p0323
1039 template<>
1040 class unexpected_type< std::exception_ptr >
1041 {
1042 public:
1043     using error_type = std::exception_ptr;
1044
1045     unexpected_type() = delete;
1046
1047     ~unexpected_type(){}
1048
1049     explicit unexpected_type( std::exception_ptr const & error )
1050     : m_error( error )
1051     {}
1052
1053     explicit unexpected_type(std::exception_ptr && error )
1054     : m_error( std::move( error ) )
1055     {}
1056
1057     template< typename E >
1058     explicit unexpected_type( E error )
1059     : m_error( std::make_exception_ptr( error ) )
1060     {}
1061
1062     std::exception_ptr const & value() const
1063     {
1064         return m_error;
1065     }
1066
1067     std::exception_ptr & value()
1068     {
1069         return m_error;
1070     }
1071
1072 private:
1073     std::exception_ptr m_error;
1074 };
1075
1076 #endif // nsel_P0323R
1077 #endif // !nsel_CONFIG_NO_EXCEPTIONS
1078
1079 /// x.x.4, Unexpected equality operators
1080
1081 template< typename E1, typename E2 >
1082 constexpr bool operator==( unexpected_type<E1> const & x, unexpected_type<E2> const & y )
1083 {
1084     return x.value() == y.value();
1085 }
1086
1087 template< typename E1, typename E2 >
1088 constexpr bool operator!=( unexpected_type<E1> const & x, unexpected_type<E2> const & y )
1089 {
1090     return ! ( x == y );
1091 }
1092
1093 #if nsel_P0323R <= 2
1094
1095 template< typename E >
1096 constexpr bool operator<( unexpected_type<E> const & x, unexpected_type<E> const & y )
1097 {
1098     return x.value() < y.value();
1099 }
1100
1101 template< typename E >
1102 constexpr bool operator>( unexpected_type<E> const & x, unexpected_type<E> const & y )
1103 {
1104     return ( y < x );
1105 }
1106
1107 template< typename E >
1108 constexpr bool operator<=( unexpected_type<E> const & x, unexpected_type<E> const & y )
1109 {
1110     return ! ( y < x  );
1111 }
1112
1113 template< typename E >
1114 constexpr bool operator>=( unexpected_type<E> const & x, unexpected_type<E> const & y )
1115 {
1116     return ! ( x < y );
1117 }
1118
1119 #endif // nsel_P0323R
1120
1121 /// x.x.5 Specialized algorithms
1122
1123 template< typename E
1124     nsel_REQUIRES_T(
1125         std17::is_swappable<E>::value
1126     )
1127 >
1128 void swap( unexpected_type<E> & x, unexpected_type<E> & y) noexcept ( noexcept ( x.swap(y) ) )
1129 {
1130     x.swap( y );
1131 }
1132
1133 #if nsel_P0323R <= 2
1134
1135 // unexpected: relational operators for std::exception_ptr:
1136
1137 inline constexpr bool operator<( unexpected_type<std::exception_ptr> const & /*x*/, unexpected_type<std::exception_ptr> const & /*y*/ )
1138 {
1139     return false;
1140 }
1141
1142 inline constexpr bool operator>( unexpected_type<std::exception_ptr> const & /*x*/, unexpected_type<std::exception_ptr> const & /*y*/ )
1143 {
1144     return false;
1145 }
1146
1147 inline constexpr bool operator<=( unexpected_type<std::exception_ptr> const & x, unexpected_type<std::exception_ptr> const & y )
1148 {
1149     return ( x == y );
1150 }
1151
1152 inline constexpr bool operator>=( unexpected_type<std::exception_ptr> const & x, unexpected_type<std::exception_ptr> const & y )
1153 {
1154     return ( x == y );
1155 }
1156
1157 #endif // nsel_P0323R
1158
1159 // unexpected: traits
1160
1161 #if nsel_P0323R <= 3
1162
1163 template< typename E>
1164 struct is_unexpected : std::false_type {};
1165
1166 template< typename E>
1167 struct is_unexpected< unexpected_type<E> > : std::true_type {};
1168
1169 #endif // nsel_P0323R
1170
1171 // unexpected: factory
1172
1173 // keep make_unexpected() removed in p0323r2 for pre-C++17:
1174
1175 template< typename E>
1176 nsel_constexpr14 auto
1177 make_unexpected( E && value ) -> unexpected_type< typename std::decay<E>::type >
1178 {
1179     return unexpected_type< typename std::decay<E>::type >( std::forward<E>(value) );
1180 }
1181
1182 #if nsel_P0323R <= 3
1183
1184 /*nsel_constexpr14*/ auto inline
1185 make_unexpected_from_current_exception() -> unexpected_type< std::exception_ptr >
1186 {
1187     return unexpected_type< std::exception_ptr >( std::current_exception() );
1188 }
1189
1190 #endif // nsel_P0323R
1191
1192 /// x.x.6, x.x.7 expected access error
1193
1194 template< typename E >
1195 class bad_expected_access;
1196
1197 /// x.x.7 bad_expected_access<void>: expected access error
1198
1199 template <>
1200 class bad_expected_access< void > : public std::exception
1201 {
1202 public:
1203     explicit bad_expected_access()
1204     : std::exception()
1205     {}
1206 };
1207
1208 /// x.x.6 bad_expected_access: expected access error
1209
1210 #if !nsel_CONFIG_NO_EXCEPTIONS
1211
1212 template< typename E >
1213 class bad_expected_access : public bad_expected_access< void >
1214 {
1215 public:
1216     using error_type = E;
1217
1218     explicit bad_expected_access( error_type error )
1219     : m_error( error )
1220     {}
1221
1222     virtual char const * what() const noexcept override
1223     {
1224         return "bad_expected_access";
1225     }
1226
1227     nsel_constexpr14 error_type & error() &
1228     {
1229         return m_error;
1230     }
1231
1232     constexpr error_type const & error() const &
1233     {
1234         return m_error;
1235     }
1236
1237 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
1238
1239     nsel_constexpr14 error_type && error() &&
1240     {
1241         return std::move( m_error );
1242     }
1243
1244     constexpr error_type const && error() const &&
1245     {
1246         return std::move( m_error );
1247     }
1248
1249 #endif
1250
1251 private:
1252     error_type m_error;
1253 };
1254
1255 #endif // nsel_CONFIG_NO_EXCEPTIONS
1256
1257 /// x.x.8 unexpect tag, in_place_unexpected tag: construct an error
1258
1259 struct unexpect_t{};
1260 using in_place_unexpected_t = unexpect_t;
1261
1262 nsel_inline17 constexpr unexpect_t unexpect{};
1263 nsel_inline17 constexpr unexpect_t in_place_unexpected{};
1264
1265 /// class error_traits
1266
1267 #if nsel_CONFIG_NO_EXCEPTIONS
1268
1269 namespace detail {
1270     inline bool text( char const * /*text*/ ) { return true; }
1271 }
1272
1273 template< typename Error >
1274 struct error_traits
1275 {
1276     static void rethrow( Error const & /*e*/ )
1277     {
1278 #if nsel_CONFIG_NO_EXCEPTIONS_SEH
1279         RaiseException( EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL );
1280 #else
1281         assert( false && detail::text("throw bad_expected_access<Error>{ e };") );
1282 #endif
1283     }
1284 };
1285
1286 template<>
1287 struct error_traits< std::exception_ptr >
1288 {
1289     static void rethrow( std::exception_ptr const & /*e*/ )
1290     {
1291 #if nsel_CONFIG_NO_EXCEPTIONS_SEH
1292         RaiseException( EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL );
1293 #else
1294         assert( false && detail::text("throw bad_expected_access<std::exception_ptr>{ e };") );
1295 #endif
1296     }
1297 };
1298
1299 template<>
1300 struct error_traits< std::error_code >
1301 {
1302     static void rethrow( std::error_code const & /*e*/ )
1303     {
1304 #if nsel_CONFIG_NO_EXCEPTIONS_SEH
1305         RaiseException( EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL );
1306 #else
1307         assert( false && detail::text("throw std::system_error( e );") );
1308 #endif
1309     }
1310 };
1311
1312 #else // nsel_CONFIG_NO_EXCEPTIONS
1313
1314 template< typename Error >
1315 struct error_traits
1316 {
1317     static void rethrow( Error const & e )
1318     {
1319         throw bad_expected_access<Error>{ e };
1320     }
1321 };
1322
1323 template<>
1324 struct error_traits< std::exception_ptr >
1325 {
1326     static void rethrow( std::exception_ptr const & e )
1327     {
1328         std::rethrow_exception( e );
1329     }
1330 };
1331
1332 template<>
1333 struct error_traits< std::error_code >
1334 {
1335     static void rethrow( std::error_code const & e )
1336     {
1337         throw std::system_error( e );
1338     }
1339 };
1340
1341 #endif // nsel_CONFIG_NO_EXCEPTIONS
1342
1343 } // namespace expected_lite
1344
1345 // provide nonstd::unexpected_type:
1346
1347 using expected_lite::unexpected_type;
1348
1349 namespace expected_lite {
1350
1351 /// class expected
1352
1353 #if nsel_P0323R <= 2
1354 template< typename T, typename E = std::exception_ptr >
1355 class expected
1356 #else
1357 template< typename T, typename E >
1358 class expected
1359 #endif // nsel_P0323R
1360 {
1361 private:
1362     template< typename, typename > friend class expected;
1363
1364 public:
1365     using value_type = T;
1366     using error_type = E;
1367     using unexpected_type = nonstd::unexpected_type<E>;
1368
1369     template< typename U >
1370     struct rebind
1371     {
1372         using type = expected<U, error_type>;
1373     };
1374
1375     // x.x.4.1 constructors
1376
1377     nsel_REQUIRES_0(
1378         std::is_default_constructible<T>::value
1379     )
1380     nsel_constexpr14 expected()
1381     : contained( true )
1382     {
1383         contained.construct_value( value_type() );
1384     }
1385
1386     nsel_constexpr14 expected( expected const & ) = default;
1387     nsel_constexpr14 expected( expected &&      ) = default;
1388
1389     template< typename U, typename G
1390         nsel_REQUIRES_T(
1391             std::is_constructible<    T, U const &>::value
1392             &&  std::is_constructible<E, G const &>::value
1393             && !std::is_constructible<T, expected<U, G>       &    >::value
1394             && !std::is_constructible<T, expected<U, G>       &&   >::value
1395             && !std::is_constructible<T, expected<U, G> const &    >::value
1396             && !std::is_constructible<T, expected<U, G> const &&   >::value
1397             && !std::is_convertible<     expected<U, G>       & , T>::value
1398             && !std::is_convertible<     expected<U, G>       &&, T>::value
1399             && !std::is_convertible<     expected<U, G> const & , T>::value
1400             && !std::is_convertible<     expected<U, G> const &&, T>::value
1401             && (!std::is_convertible<U const &, T>::value || !std::is_convertible<G const &, E>::value ) /*=> explicit */
1402         )
1403     >
1404     nsel_constexpr14 explicit expected( expected<U, G> const & other )
1405     : contained( other.has_value() )
1406     {
1407         if ( has_value() ) contained.construct_value( T{ other.contained.value() } );
1408         else               contained.construct_error( E{ other.contained.error() } );
1409     }
1410
1411     template< typename U, typename G
1412         nsel_REQUIRES_T(
1413             std::is_constructible<    T, U const &>::value
1414             &&  std::is_constructible<E, G const &>::value
1415             && !std::is_constructible<T, expected<U, G>       &    >::value
1416             && !std::is_constructible<T, expected<U, G>       &&   >::value
1417             && !std::is_constructible<T, expected<U, G> const &    >::value
1418             && !std::is_constructible<T, expected<U, G> const &&   >::value
1419             && !std::is_convertible<     expected<U, G>       & , T>::value
1420             && !std::is_convertible<     expected<U, G>       &&, T>::value
1421             && !std::is_convertible<     expected<U, G> const  &, T>::value
1422             && !std::is_convertible<     expected<U, G> const &&, T>::value
1423             && !(!std::is_convertible<U const &, T>::value || !std::is_convertible<G const &, E>::value ) /*=> non-explicit */
1424         )
1425     >
1426     nsel_constexpr14 /*non-explicit*/ expected( expected<U, G> const & other )
1427     : contained( other.has_value() )
1428     {
1429         if ( has_value() ) contained.construct_value( other.contained.value() );
1430         else               contained.construct_error( other.contained.error() );
1431     }
1432
1433     template< typename U, typename G
1434         nsel_REQUIRES_T(
1435             std::is_constructible<    T, U>::value
1436             &&  std::is_constructible<E, G>::value
1437             && !std::is_constructible<T, expected<U, G>       &    >::value
1438             && !std::is_constructible<T, expected<U, G>       &&   >::value
1439             && !std::is_constructible<T, expected<U, G> const &    >::value
1440             && !std::is_constructible<T, expected<U, G> const &&   >::value
1441             && !std::is_convertible<     expected<U, G>       & , T>::value
1442             && !std::is_convertible<     expected<U, G>       &&, T>::value
1443             && !std::is_convertible<     expected<U, G> const & , T>::value
1444             && !std::is_convertible<     expected<U, G> const &&, T>::value
1445             && (!std::is_convertible<U, T>::value || !std::is_convertible<G, E>::value ) /*=> explicit */
1446         )
1447     >
1448     nsel_constexpr14 explicit expected( expected<U, G> && other )
1449     : contained( other.has_value() )
1450     {
1451         if ( has_value() ) contained.construct_value( T{ std::move( other.contained.value() ) } );
1452         else               contained.construct_error( E{ std::move( other.contained.error() ) } );
1453     }
1454
1455     template< typename U, typename G
1456         nsel_REQUIRES_T(
1457             std::is_constructible<    T, U>::value
1458             &&  std::is_constructible<E, G>::value
1459             && !std::is_constructible<T, expected<U, G>      &     >::value
1460             && !std::is_constructible<T, expected<U, G>      &&    >::value
1461             && !std::is_constructible<T, expected<U, G> const &    >::value
1462             && !std::is_constructible<T, expected<U, G> const &&   >::value
1463             && !std::is_convertible<     expected<U, G>       & , T>::value
1464             && !std::is_convertible<     expected<U, G>       &&, T>::value
1465             && !std::is_convertible<     expected<U, G> const & , T>::value
1466             && !std::is_convertible<     expected<U, G> const &&, T>::value
1467             && !(!std::is_convertible<U, T>::value || !std::is_convertible<G, E>::value ) /*=> non-explicit */
1468         )
1469     >
1470     nsel_constexpr14 /*non-explicit*/ expected( expected<U, G> && other )
1471     : contained( other.has_value() )
1472     {
1473         if ( has_value() ) contained.construct_value( std::move( other.contained.value() ) );
1474         else               contained.construct_error( std::move( other.contained.error() ) );
1475     }
1476
1477     template< typename U = T
1478         nsel_REQUIRES_T(
1479             std::is_copy_constructible<U>::value
1480         )
1481     >
1482     nsel_constexpr14 expected( value_type const & value )
1483     : contained( true )
1484     {
1485         contained.construct_value( value );
1486     }
1487
1488     template< typename U = T
1489         nsel_REQUIRES_T(
1490             std::is_constructible<T,U&&>::value
1491             && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
1492             && !std::is_same<        expected<T,E>     , typename std20::remove_cvref<U>::type>::value
1493             && !std::is_same<nonstd::unexpected_type<E>, typename std20::remove_cvref<U>::type>::value
1494             && !std::is_convertible<U&&,T>::value /*=> explicit */
1495         )
1496     >
1497     nsel_constexpr14 explicit expected( U && value ) noexcept
1498     (
1499         std::is_nothrow_move_constructible<U>::value &&
1500         std::is_nothrow_move_constructible<E>::value
1501     )
1502     : contained( true )
1503     {
1504         contained.construct_value( T{ std::forward<U>( value ) } );
1505     }
1506
1507     template< typename U = T
1508         nsel_REQUIRES_T(
1509             std::is_constructible<T,U&&>::value
1510             && !std::is_same<typename std20::remove_cvref<U>::type, nonstd_lite_in_place_t(U)>::value
1511             && !std::is_same<        expected<T,E>     , typename std20::remove_cvref<U>::type>::value
1512             && !std::is_same<nonstd::unexpected_type<E>, typename std20::remove_cvref<U>::type>::value
1513             &&  std::is_convertible<U&&,T>::value /*=> non-explicit */
1514         )
1515     >
1516     nsel_constexpr14 /*non-explicit*/ expected( U && value ) noexcept
1517     (
1518         std::is_nothrow_move_constructible<U>::value &&
1519         std::is_nothrow_move_constructible<E>::value
1520     )
1521     : contained( true )
1522     {
1523         contained.construct_value( std::forward<U>( value ) );
1524     }
1525
1526     // construct error:
1527
1528     template< typename G = E
1529         nsel_REQUIRES_T(
1530             std::is_constructible<E, G const &   >::value
1531             && !std::is_convertible< G const &, E>::value /*=> explicit */
1532         )
1533     >
1534     nsel_constexpr14 explicit expected( nonstd::unexpected_type<G> const & error )
1535     : contained( false )
1536     {
1537         contained.construct_error( E{ error.value() } );
1538     }
1539
1540     template< typename G = E
1541             nsel_REQUIRES_T(
1542             std::is_constructible<E, G const &   >::value
1543             && std::is_convertible<  G const &, E>::value /*=> non-explicit */
1544         )
1545     >
1546     nsel_constexpr14 /*non-explicit*/ expected( nonstd::unexpected_type<G> const & error )
1547     : contained( false )
1548     {
1549         contained.construct_error( error.value() );
1550     }
1551
1552     template< typename G = E
1553         nsel_REQUIRES_T(
1554             std::is_constructible<E, G&&   >::value
1555             && !std::is_convertible< G&&, E>::value /*=> explicit */
1556         )
1557     >
1558     nsel_constexpr14 explicit expected( nonstd::unexpected_type<G> && error )
1559     : contained( false )
1560     {
1561         contained.construct_error( E{ std::move( error.value() ) } );
1562     }
1563
1564     template< typename G = E
1565         nsel_REQUIRES_T(
1566             std::is_constructible<E, G&&   >::value
1567             && std::is_convertible<  G&&, E>::value /*=> non-explicit */
1568         )
1569     >
1570     nsel_constexpr14 /*non-explicit*/ expected( nonstd::unexpected_type<G> && error )
1571     : contained( false )
1572     {
1573         contained.construct_error( std::move( error.value() ) );
1574     }
1575
1576     // in-place construction, value
1577
1578     template< typename... Args
1579         nsel_REQUIRES_T(
1580             std::is_constructible<T, Args&&...>::value
1581         )
1582     >
1583     nsel_constexpr14 explicit expected( nonstd_lite_in_place_t(T), Args&&... args )
1584     : contained( true )
1585     {
1586         contained.emplace_value( std::forward<Args>( args )... );
1587     }
1588
1589     template< typename U, typename... Args
1590         nsel_REQUIRES_T(
1591             std::is_constructible<T, std::initializer_list<U>, Args&&...>::value
1592         )
1593     >
1594     nsel_constexpr14 explicit expected( nonstd_lite_in_place_t(T), std::initializer_list<U> il, Args&&... args )
1595     : contained( true )
1596     {
1597         contained.emplace_value( il, std::forward<Args>( args )... );
1598     }
1599
1600     // in-place construction, error
1601
1602     template< typename... Args
1603         nsel_REQUIRES_T(
1604             std::is_constructible<E, Args&&...>::value
1605         )
1606     >
1607     nsel_constexpr14 explicit expected( unexpect_t, Args&&... args )
1608     : contained( false )
1609     {
1610         contained.emplace_error( std::forward<Args>( args )... );
1611     }
1612
1613     template< typename U, typename... Args
1614         nsel_REQUIRES_T(
1615             std::is_constructible<E, std::initializer_list<U>, Args&&...>::value
1616         )
1617     >
1618     nsel_constexpr14 explicit expected( unexpect_t, std::initializer_list<U> il, Args&&... args )
1619     : contained( false )
1620     {
1621         contained.emplace_error( il, std::forward<Args>( args )... );
1622     }
1623
1624     // x.x.4.2 destructor
1625
1626     // TODO: ~expected: triviality
1627     // Effects: If T is not cv void and is_trivially_destructible_v<T> is false and bool(*this), calls val.~T(). If is_trivially_destructible_v<E> is false and !bool(*this), calls unexpect.~unexpected<E>().
1628     // Remarks: If either T is cv void or is_trivially_destructible_v<T> is true, and is_trivially_destructible_v<E> is true, then this destructor shall be a trivial destructor.
1629
1630     ~expected()
1631     {
1632         if ( has_value() ) contained.destruct_value();
1633         else               contained.destruct_error();
1634     }
1635
1636     // x.x.4.3 assignment
1637
1638     expected & operator=( expected const & other )
1639     {
1640         expected( other ).swap( *this );
1641         return *this;
1642     }
1643
1644     expected & operator=( expected && other ) noexcept
1645     (
1646         std::is_nothrow_move_constructible<   T>::value
1647         && std::is_nothrow_move_assignable<   T>::value
1648         && std::is_nothrow_move_constructible<E>::value     // added for missing
1649         && std::is_nothrow_move_assignable<   E>::value )   //   nothrow above
1650     {
1651         expected( std::move( other ) ).swap( *this );
1652         return *this;
1653     }
1654
1655     template< typename U
1656         nsel_REQUIRES_T(
1657             !std::is_same<expected<T,E>, typename std20::remove_cvref<U>::type>::value
1658             && std17::conjunction<std::is_scalar<T>, std::is_same<T, std::decay<U>> >::value
1659             && std::is_constructible<T ,U>::value
1660             && std::is_assignable<   T&,U>::value
1661             && std::is_nothrow_move_constructible<E>::value )
1662     >
1663     expected & operator=( U && value )
1664     {
1665         expected( std::forward<U>( value ) ).swap( *this );
1666         return *this;
1667     }
1668
1669     template< typename G = E
1670         nsel_REQUIRES_T(
1671             std::is_constructible<E, G const&>::value &&
1672             std::is_copy_constructible<G>::value    // TODO: std::is_nothrow_copy_constructible<G>
1673             && std::is_copy_assignable<G>::value
1674         )
1675     >
1676     expected & operator=( nonstd::unexpected_type<G> const & error )
1677     {
1678         expected( unexpect, error.value() ).swap( *this );
1679         return *this;
1680     }
1681
1682     template< typename G = E
1683         nsel_REQUIRES_T(
1684             std::is_constructible<E, G&&>::value &&
1685             std::is_move_constructible<G>::value    // TODO: std::is_nothrow_move_constructible<G>
1686             && std::is_move_assignable<G>::value
1687         )
1688     >
1689     expected & operator=( nonstd::unexpected_type<G> && error )
1690     {
1691         expected( unexpect, std::move( error.value() ) ).swap( *this );
1692         return *this;
1693     }
1694
1695     template< typename... Args
1696         nsel_REQUIRES_T(
1697             std::is_nothrow_constructible<T, Args&&...>::value
1698         )
1699     >
1700     value_type & emplace( Args &&... args )
1701     {
1702         expected( nonstd_lite_in_place(T), std::forward<Args>(args)... ).swap( *this );
1703         return value();
1704     }
1705
1706     template< typename U, typename... Args
1707         nsel_REQUIRES_T(
1708             std::is_nothrow_constructible<T, std::initializer_list<U>&, Args&&...>::value
1709         )
1710     >
1711     value_type & emplace( std::initializer_list<U> il, Args &&... args )
1712     {
1713         expected( nonstd_lite_in_place(T), il, std::forward<Args>(args)... ).swap( *this );
1714         return value();
1715     }
1716
1717     // x.x.4.4 swap
1718
1719     template< typename U=T, typename G=E >
1720     nsel_REQUIRES_R( void,
1721         std17::is_swappable<   U>::value
1722         && std17::is_swappable<G>::value
1723         && ( std::is_move_constructible<U>::value || std::is_move_constructible<G>::value )
1724     )
1725     swap( expected & other ) noexcept
1726     (
1727         std::is_nothrow_move_constructible<T>::value && std17::is_nothrow_swappable<T&>::value &&
1728         std::is_nothrow_move_constructible<E>::value && std17::is_nothrow_swappable<E&>::value
1729     )
1730     {
1731         using std::swap;
1732
1733         if      (   bool(*this) &&   bool(other) ) { swap( contained.value(), other.contained.value() ); }
1734         else if ( ! bool(*this) && ! bool(other) ) { swap( contained.error(), other.contained.error() ); }
1735         else if (   bool(*this) && ! bool(other) ) { error_type t( std::move( other.error() ) );
1736                                                      other.contained.destruct_error();
1737                                                      other.contained.construct_value( std::move( contained.value() ) );
1738                                                      contained.destruct_value();
1739                                                      contained.construct_error( std::move( t ) );
1740                                                      bool has_value = contained.has_value();
1741                                                      bool other_has_value = other.has_value();
1742                                                      other.contained.set_has_value(has_value);
1743                                                      contained.set_has_value(other_has_value);
1744                                                    }
1745         else if ( ! bool(*this) &&   bool(other) ) { other.swap( *this ); }
1746     }
1747
1748     // x.x.4.5 observers
1749
1750     constexpr value_type const * operator ->() const
1751     {
1752         return assert( has_value() ), contained.value_ptr();
1753     }
1754
1755     value_type * operator ->()
1756     {
1757         return assert( has_value() ), contained.value_ptr();
1758     }
1759
1760     constexpr value_type const & operator *() const &
1761     {
1762         return assert( has_value() ), contained.value();
1763     }
1764
1765     value_type & operator *() &
1766     {
1767         return assert( has_value() ), contained.value();
1768     }
1769
1770 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
1771
1772     constexpr value_type const && operator *() const &&
1773     {
1774         return std::move( ( assert( has_value() ), contained.value() ) );
1775     }
1776
1777     nsel_constexpr14 value_type && operator *() &&
1778     {
1779         return std::move( ( assert( has_value() ), contained.value() ) );
1780     }
1781
1782 #endif
1783
1784     constexpr explicit operator bool() const noexcept
1785     {
1786         return has_value();
1787     }
1788
1789     constexpr bool has_value() const noexcept
1790     {
1791         return contained.has_value();
1792     }
1793
1794     constexpr value_type const & value() const &
1795     {
1796         return has_value()
1797             ? ( contained.value() )
1798             : ( error_traits<error_type>::rethrow( contained.error() ), contained.value() );
1799     }
1800
1801     value_type & value() &
1802     {
1803         return has_value()
1804             ? ( contained.value() )
1805             : ( error_traits<error_type>::rethrow( contained.error() ), contained.value() );
1806     }
1807
1808 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
1809
1810     constexpr value_type const && value() const &&
1811     {
1812         return std::move( has_value()
1813             ? ( contained.value() )
1814             : ( error_traits<error_type>::rethrow( contained.error() ), contained.value() ) );
1815     }
1816
1817     nsel_constexpr14 value_type && value() &&
1818     {
1819         return std::move( has_value()
1820             ? ( contained.value() )
1821             : ( error_traits<error_type>::rethrow( contained.error() ), contained.value() ) );
1822     }
1823
1824 #endif
1825
1826     constexpr error_type const & error() const &
1827     {
1828         return assert( ! has_value() ), contained.error();
1829     }
1830
1831     error_type & error() &
1832     {
1833         return assert( ! has_value() ), contained.error();
1834     }
1835
1836 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
1837
1838     constexpr error_type const && error() const &&
1839     {
1840         return std::move( ( assert( ! has_value() ), contained.error() ) );
1841     }
1842
1843     error_type && error() &&
1844     {
1845         return std::move( ( assert( ! has_value() ), contained.error() ) );
1846     }
1847
1848 #endif
1849
1850     constexpr unexpected_type get_unexpected() const
1851     {
1852         return make_unexpected( contained.error() );
1853     }
1854
1855     template< typename Ex >
1856     bool has_exception() const
1857     {
1858         using ContainedEx = typename std::remove_reference< decltype( get_unexpected().value() ) >::type;
1859         return ! has_value() && std::is_base_of< Ex, ContainedEx>::value;
1860     }
1861
1862     template< typename U
1863         nsel_REQUIRES_T(
1864             std::is_copy_constructible< T>::value
1865             && std::is_convertible<U&&, T>::value
1866         )
1867     >
1868     value_type value_or( U && v ) const &
1869     {
1870         return has_value()
1871             ? contained.value()
1872             : static_cast<T>( std::forward<U>( v ) );
1873     }
1874
1875     template< typename U
1876         nsel_REQUIRES_T(
1877             std::is_move_constructible< T>::value
1878             && std::is_convertible<U&&, T>::value
1879         )
1880     >
1881     value_type value_or( U && v ) &&
1882     {
1883         return has_value()
1884             ? std::move( contained.value() )
1885             : static_cast<T>( std::forward<U>( v ) );
1886     }
1887
1888     // unwrap()
1889
1890 //  template <class U, class E>
1891 //  constexpr expected<U,E> expected<expected<U,E>,E>::unwrap() const&;
1892
1893 //  template <class T, class E>
1894 //  constexpr expected<T,E> expected<T,E>::unwrap() const&;
1895
1896 //  template <class U, class E>
1897 //  expected<U,E> expected<expected<U,E>, E>::unwrap() &&;
1898
1899 //  template <class T, class E>
1900 //  template expected<T,E> expected<T,E>::unwrap() &&;
1901
1902     // factories
1903
1904 //  template< typename Ex, typename F>
1905 //  expected<T,E> catch_exception(F&& f);
1906
1907 //  template< typename F>
1908 //  expected<decltype(func(declval<T>())),E> map(F&& func) ;
1909
1910 //  template< typename F>
1911 //  'see below' bind(F&& func);
1912
1913 //  template< typename F>
1914 //  expected<T,E> catch_error(F&& f);
1915
1916 //  template< typename F>
1917 //  'see below' then(F&& func);
1918
1919 private:
1920     detail::storage_t
1921     <
1922         T
1923         ,E
1924         , std::is_copy_constructible<T>::value && std::is_copy_constructible<E>::value
1925         , std::is_move_constructible<T>::value && std::is_move_constructible<E>::value
1926     >
1927     contained;
1928 };
1929
1930 /// class expected, void specialization
1931
1932 template< typename E >
1933 class expected<void, E>
1934 {
1935 private:
1936     template< typename, typename > friend class expected;
1937
1938 public:
1939     using value_type = void;
1940     using error_type = E;
1941     using unexpected_type = nonstd::unexpected_type<E>;
1942
1943     // x.x.4.1 constructors
1944
1945     constexpr expected() noexcept
1946         : contained( true )
1947     {}
1948
1949     nsel_constexpr14 expected( expected const & other ) = default;
1950     nsel_constexpr14 expected( expected &&      other ) = default;
1951
1952     constexpr explicit expected( nonstd_lite_in_place_t(void) )
1953         : contained( true )
1954     {}
1955
1956     template< typename G = E
1957         nsel_REQUIRES_T(
1958             !std::is_convertible<G const &, E>::value /*=> explicit */
1959         )
1960     >
1961     nsel_constexpr14 explicit expected( nonstd::unexpected_type<G> const & error )
1962         : contained( false )
1963     {
1964         contained.construct_error( E{ error.value() } );
1965     }
1966
1967     template< typename G = E
1968         nsel_REQUIRES_T(
1969             std::is_convertible<G const &, E>::value /*=> non-explicit */
1970         )
1971     >
1972     nsel_constexpr14 /*non-explicit*/ expected( nonstd::unexpected_type<G> const & error )
1973         : contained( false )
1974     {
1975         contained.construct_error( error.value() );
1976     }
1977
1978     template< typename G = E
1979         nsel_REQUIRES_T(
1980             !std::is_convertible<G&&, E>::value /*=> explicit */
1981         )
1982     >
1983     nsel_constexpr14 explicit expected( nonstd::unexpected_type<G> && error )
1984         : contained( false )
1985     {
1986         contained.construct_error( E{ std::move( error.value() ) } );
1987     }
1988
1989     template< typename G = E
1990         nsel_REQUIRES_T(
1991             std::is_convertible<G&&, E>::value /*=> non-explicit */
1992         )
1993     >
1994     nsel_constexpr14 /*non-explicit*/ expected( nonstd::unexpected_type<G> && error )
1995         : contained( false )
1996     {
1997         contained.construct_error( std::move( error.value() ) );
1998     }
1999
2000     template< typename... Args
2001         nsel_REQUIRES_T(
2002             std::is_constructible<E, Args&&...>::value
2003         )
2004     >
2005     nsel_constexpr14 explicit expected( unexpect_t, Args&&... args )
2006         : contained( false )
2007     {
2008         contained.emplace_error( std::forward<Args>( args )... );
2009     }
2010
2011     template< typename U, typename... Args
2012         nsel_REQUIRES_T(
2013             std::is_constructible<E, std::initializer_list<U>, Args&&...>::value
2014         )
2015     >
2016     nsel_constexpr14 explicit expected( unexpect_t, std::initializer_list<U> il, Args&&... args )
2017         : contained( false )
2018     {
2019         contained.emplace_error( il, std::forward<Args>( args )... );
2020     }
2021
2022     // destructor
2023
2024     ~expected()
2025     {
2026         if ( ! has_value() )
2027         {
2028             contained.destruct_error();
2029         }
2030     }
2031
2032     // x.x.4.3 assignment
2033
2034     expected & operator=( expected const & other )
2035     {
2036         expected( other ).swap( *this );
2037         return *this;
2038     }
2039
2040     expected & operator=( expected && other ) noexcept
2041     (
2042         std::is_nothrow_move_assignable<E>::value &&
2043         std::is_nothrow_move_constructible<E>::value )
2044     {
2045         expected( std::move( other ) ).swap( *this );
2046         return *this;
2047     }
2048
2049     void emplace()
2050     {
2051         expected().swap( *this );
2052     }
2053
2054     // x.x.4.4 swap
2055
2056     template< typename G = E >
2057     nsel_REQUIRES_R( void,
2058         std17::is_swappable<G>::value
2059         && std::is_move_constructible<G>::value
2060     )
2061     swap( expected & other ) noexcept
2062     (
2063         std::is_nothrow_move_constructible<E>::value && std17::is_nothrow_swappable<E&>::value
2064     )
2065     {
2066         using std::swap;
2067
2068         if      ( ! bool(*this) && ! bool(other) ) { swap( contained.error(), other.contained.error() ); }
2069         else if (   bool(*this) && ! bool(other) ) { contained.construct_error( std::move( other.error() ) );
2070                                                      bool has_value = contained.has_value();
2071                                                      bool other_has_value = other.has_value();
2072                                                      other.contained.set_has_value(has_value);
2073                                                      contained.set_has_value(other_has_value);
2074                                                      }
2075         else if ( ! bool(*this) &&   bool(other) ) { other.swap( *this ); }
2076     }
2077
2078     // x.x.4.5 observers
2079
2080     constexpr explicit operator bool() const noexcept
2081     {
2082         return has_value();
2083     }
2084
2085     constexpr bool has_value() const noexcept
2086     {
2087         return contained.has_value();
2088     }
2089
2090     void value() const
2091     {
2092         if ( ! has_value() )
2093         {
2094             error_traits<error_type>::rethrow( contained.error() );
2095         }
2096     }
2097
2098     constexpr error_type const & error() const &
2099     {
2100         return assert( ! has_value() ), contained.error();
2101     }
2102
2103     error_type & error() &
2104     {
2105         return assert( ! has_value() ), contained.error();
2106     }
2107
2108 #if !nsel_COMPILER_GNUC_VERSION || nsel_COMPILER_GNUC_VERSION >= 490
2109
2110     constexpr error_type const && error() const &&
2111     {
2112         return std::move( ( assert( ! has_value() ), contained.error() ) );
2113     }
2114
2115     error_type && error() &&
2116     {
2117         return std::move( ( assert( ! has_value() ), contained.error() ) );
2118     }
2119
2120 #endif
2121
2122     constexpr unexpected_type get_unexpected() const
2123     {
2124         return make_unexpected( contained.error() );
2125     }
2126
2127     template< typename Ex >
2128     bool has_exception() const
2129     {
2130         using ContainedEx = typename std::remove_reference< decltype( get_unexpected().value() ) >::type;
2131         return ! has_value() && std::is_base_of< Ex, ContainedEx>::value;
2132     }
2133
2134 //  template constexpr 'see below' unwrap() const&;
2135 //
2136 //  template 'see below' unwrap() &&;
2137
2138     // factories
2139
2140 //  template< typename Ex, typename F>
2141 //  expected<void,E> catch_exception(F&& f);
2142 //
2143 //  template< typename F>
2144 //  expected<decltype(func()), E> map(F&& func) ;
2145 //
2146 //  template< typename F>
2147 //  'see below' bind(F&& func) ;
2148 //
2149 //  template< typename F>
2150 //  expected<void,E> catch_error(F&& f);
2151 //
2152 //  template< typename F>
2153 //  'see below' then(F&& func);
2154
2155 private:
2156     detail::storage_t
2157     <
2158         void
2159         , E
2160         , std::is_copy_constructible<E>::value
2161         , std::is_move_constructible<E>::value
2162     >
2163     contained;
2164 };
2165
2166 // x.x.4.6 expected<>: comparison operators
2167
2168 template< typename T1, typename E1, typename T2, typename E2
2169     nsel_REQUIRES_T(
2170         !std::is_void<T1>::value && !std::is_void<T2>::value
2171     )
2172 >
2173 constexpr bool operator==( expected<T1,E1> const & x, expected<T2,E2> const & y )
2174 {
2175     return bool(x) != bool(y) ? false : bool(x) ? *x == *y : x.error() == y.error();
2176 }
2177
2178 template< typename T1, typename E1, typename T2, typename E2
2179     nsel_REQUIRES_T(
2180         std::is_void<T1>::value && std::is_void<T2>::value
2181     )
2182 >
2183 constexpr bool operator==( expected<T1,E1> const & x, expected<T2,E2> const & y )
2184 {
2185     return bool(x) != bool(y) ? false : bool(x) || static_cast<bool>( x.error() == y.error() );
2186 }
2187
2188 template< typename T1, typename E1, typename T2, typename E2 >
2189 constexpr bool operator!=( expected<T1,E1> const & x, expected<T2,E2> const & y )
2190 {
2191     return !(x == y);
2192 }
2193
2194 #if nsel_P0323R <= 2
2195
2196 template< typename T, typename E >
2197 constexpr bool operator<( expected<T,E> const & x, expected<T,E> const & y )
2198 {
2199     return (!y) ? false : (!x) ? true : *x < *y;
2200 }
2201
2202 template< typename T, typename E >
2203 constexpr bool operator>( expected<T,E> const & x, expected<T,E> const & y )
2204 {
2205     return (y < x);
2206 }
2207
2208 template< typename T, typename E >
2209 constexpr bool operator<=( expected<T,E> const & x, expected<T,E> const & y )
2210 {
2211     return !(y < x);
2212 }
2213
2214 template< typename T, typename E >
2215 constexpr bool operator>=( expected<T,E> const & x, expected<T,E> const & y )
2216 {
2217     return !(x < y);
2218 }
2219
2220 #endif
2221
2222 // x.x.4.7 expected: comparison with T
2223
2224 template< typename T1, typename E1, typename T2
2225     nsel_REQUIRES_T(
2226         !std::is_void<T1>::value
2227     )
2228 >
2229 constexpr bool operator==( expected<T1,E1> const & x, T2 const & v )
2230 {
2231     return bool(x) ? *x == v : false;
2232 }
2233
2234 template< typename T1, typename E1, typename T2
2235     nsel_REQUIRES_T(
2236         !std::is_void<T1>::value
2237     )
2238 >
2239 constexpr bool operator==(T2 const & v, expected<T1,E1> const & x )
2240 {
2241     return bool(x) ? v == *x : false;
2242 }
2243
2244 template< typename T1, typename E1, typename T2 >
2245 constexpr bool operator!=( expected<T1,E1> const & x, T2 const & v )
2246 {
2247     return bool(x) ? *x != v : true;
2248 }
2249
2250 template< typename T1, typename E1, typename T2 >
2251 constexpr bool operator!=( T2 const & v, expected<T1,E1> const & x )
2252 {
2253     return bool(x) ? v != *x : true;
2254 }
2255
2256 #if nsel_P0323R <= 2
2257
2258 template< typename T, typename E >
2259 constexpr bool operator<( expected<T,E> const & x, T const & v )
2260 {
2261     return bool(x) ? *x < v : true;
2262 }
2263
2264 template< typename T, typename E >
2265 constexpr bool operator<( T const & v, expected<T,E> const & x )
2266 {
2267     return bool(x) ? v < *x : false;
2268 }
2269
2270 template< typename T, typename E >
2271 constexpr bool operator>( T const & v, expected<T,E> const & x )
2272 {
2273     return bool(x) ? *x < v : false;
2274 }
2275
2276 template< typename T, typename E >
2277 constexpr bool operator>( expected<T,E> const & x, T const & v )
2278 {
2279     return bool(x) ? v < *x : false;
2280 }
2281
2282 template< typename T, typename E >
2283 constexpr bool operator<=( T const & v, expected<T,E> const & x )
2284 {
2285     return bool(x) ? ! ( *x < v ) : false;
2286 }
2287
2288 template< typename T, typename E >
2289 constexpr bool operator<=( expected<T,E> const & x, T const & v )
2290 {
2291     return bool(x) ? ! ( v < *x ) : true;
2292 }
2293
2294 template< typename T, typename E >
2295 constexpr bool operator>=( expected<T,E> const & x, T const & v )
2296 {
2297     return bool(x) ? ! ( *x < v ) : false;
2298 }
2299
2300 template< typename T, typename E >
2301 constexpr bool operator>=( T const & v, expected<T,E> const & x )
2302 {
2303     return bool(x) ? ! ( v < *x ) : true;
2304 }
2305
2306 #endif // nsel_P0323R
2307
2308 // x.x.4.8 expected: comparison with unexpected_type
2309
2310 template< typename T1, typename E1 , typename E2 >
2311 constexpr bool operator==( expected<T1,E1> const & x, unexpected_type<E2> const & u )
2312 {
2313     return (!x) ? x.get_unexpected() == u : false;
2314 }
2315
2316 template< typename T1, typename E1 , typename E2 >
2317 constexpr bool operator==( unexpected_type<E2> const & u, expected<T1,E1> const & x )
2318 {
2319     return ( x == u );
2320 }
2321
2322 template< typename T1, typename E1 , typename E2 >
2323 constexpr bool operator!=( expected<T1,E1> const & x, unexpected_type<E2> const & u )
2324 {
2325     return ! ( x == u );
2326 }
2327
2328 template< typename T1, typename E1 , typename E2 >
2329 constexpr bool operator!=( unexpected_type<E2> const & u, expected<T1,E1> const & x )
2330 {
2331     return ! ( x == u );
2332 }
2333
2334 #if nsel_P0323R <= 2
2335
2336 template< typename T, typename E >
2337 constexpr bool operator<( expected<T,E> const & x, unexpected_type<E> const & u )
2338 {
2339     return (!x) ? ( x.get_unexpected() < u ) : false;
2340 }
2341
2342 template< typename T, typename E >
2343 constexpr bool operator<( unexpected_type<E> const & u, expected<T,E> const & x )
2344 {
2345   return (!x) ? ( u < x.get_unexpected() ) : true ;
2346 }
2347
2348 template< typename T, typename E >
2349 constexpr bool operator>( expected<T,E> const & x, unexpected_type<E> const & u )
2350 {
2351     return ( u < x );
2352 }
2353
2354 template< typename T, typename E >
2355 constexpr bool operator>( unexpected_type<E> const & u, expected<T,E> const & x )
2356 {
2357     return ( x < u );
2358 }
2359
2360 template< typename T, typename E >
2361 constexpr bool operator<=( expected<T,E> const & x, unexpected_type<E> const & u )
2362 {
2363     return ! ( u < x );
2364 }
2365
2366 template< typename T, typename E >
2367 constexpr bool operator<=( unexpected_type<E> const & u, expected<T,E> const & x)
2368 {
2369     return ! ( x < u );
2370 }
2371
2372 template< typename T, typename E >
2373 constexpr bool operator>=( expected<T,E> const & x, unexpected_type<E> const & u  )
2374 {
2375     return ! ( u > x );
2376 }
2377
2378 template< typename T, typename E >
2379 constexpr bool operator>=( unexpected_type<E> const & u, expected<T,E> const & x )
2380 {
2381     return ! ( x > u );
2382 }
2383
2384 #endif // nsel_P0323R
2385
2386 /// x.x.x Specialized algorithms
2387
2388 template< typename T, typename E
2389     nsel_REQUIRES_T(
2390         ( std::is_void<T>::value || std::is_move_constructible<T>::value )
2391         && std::is_move_constructible<E>::value
2392         && std17::is_swappable<T>::value
2393         && std17::is_swappable<E>::value )
2394 >
2395 void swap( expected<T,E> & x, expected<T,E> & y ) noexcept ( noexcept ( x.swap(y) ) )
2396 {
2397     x.swap( y );
2398 }
2399
2400 #if nsel_P0323R <= 3
2401
2402 template< typename T >
2403 constexpr auto make_expected( T && v ) -> expected< typename std::decay<T>::type >
2404 {
2405     return expected< typename std::decay<T>::type >( std::forward<T>( v ) );
2406 }
2407
2408 // expected<void> specialization:
2409
2410 auto inline make_expected() -> expected<void>
2411 {
2412     return expected<void>( in_place );
2413 }
2414
2415 template< typename T >
2416 constexpr auto make_expected_from_current_exception() -> expected<T>
2417 {
2418     return expected<T>( make_unexpected_from_current_exception() );
2419 }
2420
2421 template< typename T >
2422 auto make_expected_from_exception( std::exception_ptr v ) -> expected<T>
2423 {
2424     return expected<T>( unexpected_type<std::exception_ptr>( std::forward<std::exception_ptr>( v ) ) );
2425 }
2426
2427 template< typename T, typename E >
2428 constexpr auto make_expected_from_error( E e ) -> expected<T, typename std::decay<E>::type>
2429 {
2430     return expected<T, typename std::decay<E>::type>( make_unexpected( e ) );
2431 }
2432
2433 template< typename F
2434     nsel_REQUIRES_T( ! std::is_same<typename std::result_of<F()>::type, void>::value )
2435 >
2436 /*nsel_constexpr14*/
2437 auto make_expected_from_call( F f ) -> expected< typename std::result_of<F()>::type >
2438 {
2439     try
2440     {
2441         return make_expected( f() );
2442     }
2443     catch (...)
2444     {
2445         return make_unexpected_from_current_exception();
2446     }
2447 }
2448
2449 template< typename F
2450     nsel_REQUIRES_T( std::is_same<typename std::result_of<F()>::type, void>::value )
2451 >
2452 /*nsel_constexpr14*/
2453 auto make_expected_from_call( F f ) -> expected<void>
2454 {
2455     try
2456     {
2457         f();
2458         return make_expected();
2459     }
2460     catch (...)
2461     {
2462         return make_unexpected_from_current_exception();
2463     }
2464 }
2465
2466 #endif // nsel_P0323R
2467
2468 } // namespace expected_lite
2469
2470 using namespace expected_lite;
2471
2472 // using expected_lite::expected;
2473 // using ...
2474
2475 } // namespace nonstd
2476
2477 namespace std {
2478
2479 // expected: hash support
2480
2481 template< typename T, typename E >
2482 struct hash< nonstd::expected<T,E> >
2483 {
2484     using result_type = std::size_t;
2485     using argument_type = nonstd::expected<T,E>;
2486
2487     constexpr result_type operator()(argument_type const & arg) const
2488     {
2489         return arg ? std::hash<T>{}(*arg) : result_type{};
2490     }
2491 };
2492
2493 // TBD - ?? remove? see spec.
2494 template< typename T, typename E >
2495 struct hash< nonstd::expected<T&,E> >
2496 {
2497     using result_type = std::size_t;
2498     using argument_type = nonstd::expected<T&,E>;
2499
2500     constexpr result_type operator()(argument_type const & arg) const
2501     {
2502         return arg ? std::hash<T>{}(*arg) : result_type{};
2503     }
2504 };
2505
2506 // TBD - implement
2507 // bool(e), hash<expected<void,E>>()(e) shall evaluate to the hashing true;
2508 // otherwise it evaluates to an unspecified value if E is exception_ptr or
2509 // a combination of hashing false and hash<E>()(e.error()).
2510
2511 template< typename E >
2512 struct hash< nonstd::expected<void,E> >
2513 {
2514 };
2515
2516 } // namespace std
2517
2518 namespace nonstd {
2519
2520 // void unexpected() is deprecated && removed in C++17
2521
2522 #if nsel_CPP17_OR_GREATER || nsel_COMPILER_MSVC_VERSION > 141
2523 template< typename E >
2524 using unexpected = unexpected_type<E>;
2525 #endif
2526
2527 } // namespace nonstd
2528
2529 #undef nsel_REQUIRES
2530 #undef nsel_REQUIRES_0
2531 #undef nsel_REQUIRES_T
2532
2533 nsel_RESTORE_WARNINGS()
2534
2535 #endif // nsel_USES_STD_EXPECTED
2536
2537 #endif // NONSTD_EXPECTED_LITE_HPP