1 // <expected> -*- C++ -*- 2 3 // Copyright The GNU Toolchain Authors. 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/expected 26 * This is a Standard C++ Library header. 27 */ 28 29 #ifndef _GLIBCXX_EXPECTED 30 #define _GLIBCXX_EXPECTED 31 32 #pragma GCC system_header 33 34 #define __glibcxx_want_expected 35 #define __glibcxx_want_freestanding_expected 36 #include <bits/version.h> 37 38 #ifdef __cpp_lib_expected // C++ >= 23 && __cpp_concepts >= 202002L 39 #include <initializer_list> 40 #include <bits/exception.h> // exception 41 #include <bits/invoke.h> // __invoke 42 #include <bits/stl_construct.h> // construct_at 43 #include <bits/utility.h> // in_place_t 44 45 namespace std _GLIBCXX_VISIBILITY(default) 46 { 47 _GLIBCXX_BEGIN_NAMESPACE_VERSION 48 49 /** 50 * @defgroup expected_values Expected values 51 * @addtogroup utilities 52 * @since C++23 53 * @{ 54 */ 55 56 /// Discriminated union that holds an expected value or an error value. 57 /** 58 * @since C++23 59 */ 60 template<typename _Tp, typename _Er> 61 class expected; 62 63 /// Wrapper type used to pass an error value to a `std::expected`. 64 /** 65 * @since C++23 66 */ 67 template<typename _Er> 68 class unexpected; 69 70 /// Exception thrown by std::expected when the value() is not present. 71 /** 72 * @since C++23 73 */ 74 template<typename _Er> 75 class bad_expected_access; 76 77 template<> 78 class bad_expected_access<void> : public exception 79 { 80 protected: 81 bad_expected_access() noexcept { } 82 bad_expected_access(const bad_expected_access&) = default; 83 bad_expected_access(bad_expected_access&&) = default; 84 bad_expected_access& operator=(const bad_expected_access&) = default; 85 bad_expected_access& operator=(bad_expected_access&&) = default; 86 ~bad_expected_access() = default; 87 88 public: 89 90 [[nodiscard]] 91 const char* 92 what() const noexcept override 93 { return "bad access to std::expected without expected value"; } 94 }; 95 96 template<typename _Er> 97 class bad_expected_access : public bad_expected_access<void> { 98 public: 99 explicit 100 bad_expected_access(_Er __e) : _M_unex(std::move(__e)) { } 101 102 // XXX const char* what() const noexcept override; 103 104 [[nodiscard]] 105 _Er& 106 error() & noexcept 107 { return _M_unex; } 108 109 [[nodiscard]] 110 const _Er& 111 error() const & noexcept 112 { return _M_unex; } 113 114 [[nodiscard]] 115 _Er&& 116 error() && noexcept 117 { return std::move(_M_unex); } 118 119 [[nodiscard]] 120 const _Er&& 121 error() const && noexcept 122 { return std::move(_M_unex); } 123 124 private: 125 _Er _M_unex; 126 }; 127 128 /// Tag type for constructing unexpected values in a std::expected 129 /** 130 * @since C++23 131 */ 132 struct unexpect_t 133 { 134 explicit unexpect_t() = default; 135 }; 136 137 /// Tag for constructing unexpected values in a std::expected 138 /** 139 * @since C++23 140 */ 141 inline constexpr unexpect_t unexpect{}; 142 143 /// @cond undocumented 144 namespace __expected 145 { 146 template<typename _Tp> 147 constexpr bool __is_expected = false; 148 template<typename _Tp, typename _Er> 149 constexpr bool __is_expected<expected<_Tp, _Er>> = true; 150 151 template<typename _Tp> 152 constexpr bool __is_unexpected = false; 153 template<typename _Tp> 154 constexpr bool __is_unexpected<unexpected<_Tp>> = true; 155 156 template<typename _Fn, typename _Tp> 157 using __result = remove_cvref_t<invoke_result_t<_Fn&&, _Tp&&>>; 158 template<typename _Fn, typename _Tp> 159 using __result_xform = remove_cv_t<invoke_result_t<_Fn&&, _Tp&&>>; 160 template<typename _Fn> 161 using __result0 = remove_cvref_t<invoke_result_t<_Fn&&>>; 162 template<typename _Fn> 163 using __result0_xform = remove_cv_t<invoke_result_t<_Fn&&>>; 164 165 template<typename _Er> 166 concept __can_be_unexpected 167 = is_object_v<_Er> && (!is_array_v<_Er>) 168 && (!__expected::__is_unexpected<_Er>) 169 && (!is_const_v<_Er>) && (!is_volatile_v<_Er>); 170 171 // Tag types for in-place construction from an invocation result. 172 struct __in_place_inv { }; 173 struct __unexpect_inv { }; 174 } 175 /// @endcond 176 177 template<typename _Er> 178 class unexpected 179 { 180 static_assert( __expected::__can_be_unexpected<_Er> ); 181 182 public: 183 constexpr unexpected(const unexpected&) = default; 184 constexpr unexpected(unexpected&&) = default; 185 186 template<typename _Err = _Er> 187 requires (!is_same_v<remove_cvref_t<_Err>, unexpected>) 188 && (!is_same_v<remove_cvref_t<_Err>, in_place_t>) 189 && is_constructible_v<_Er, _Err> 190 constexpr explicit 191 unexpected(_Err&& __e) 192 noexcept(is_nothrow_constructible_v<_Er, _Err>) 193 : _M_unex(std::forward<_Err>(__e)) 194 { } 195 196 template<typename... _Args> 197 requires is_constructible_v<_Er, _Args...> 198 constexpr explicit 199 unexpected(in_place_t, _Args&&... __args) 200 noexcept(is_nothrow_constructible_v<_Er, _Args...>) 201 : _M_unex(std::forward<_Args>(__args)...) 202 { } 203 204 template<typename _Up, typename... _Args> 205 requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...> 206 constexpr explicit 207 unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 208 noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&, 209 _Args...>) 210 : _M_unex(__il, std::forward<_Args>(__args)...) 211 { } 212 213 constexpr unexpected& operator=(const unexpected&) = default; 214 constexpr unexpected& operator=(unexpected&&) = default; 215 216 217 [[nodiscard]] 218 constexpr const _Er& 219 error() const & noexcept { return _M_unex; } 220 221 [[nodiscard]] 222 constexpr _Er& 223 error() & noexcept { return _M_unex; } 224 225 [[nodiscard]] 226 constexpr const _Er&& 227 error() const && noexcept { return std::move(_M_unex); } 228 229 [[nodiscard]] 230 constexpr _Er&& 231 error() && noexcept { return std::move(_M_unex); } 232 233 constexpr void 234 swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Er>) 235 requires is_swappable_v<_Er> 236 { 237 using std::swap; 238 swap(_M_unex, __other._M_unex); 239 } 240 241 template<typename _Err> 242 [[nodiscard]] 243 friend constexpr bool 244 operator==(const unexpected& __x, const unexpected<_Err>& __y) 245 { return __x._M_unex == __y.error(); } 246 247 friend constexpr void 248 swap(unexpected& __x, unexpected& __y) noexcept(noexcept(__x.swap(__y))) 249 requires is_swappable_v<_Er> 250 { __x.swap(__y); } 251 252 private: 253 _Er _M_unex; 254 }; 255 256 template<typename _Er> unexpected(_Er) -> unexpected<_Er>; 257 258 /// @cond undocumented 259 namespace __expected 260 { 261 template<typename _Tp> 262 struct _Guard 263 { 264 static_assert( is_nothrow_move_constructible_v<_Tp> ); 265 266 constexpr explicit 267 _Guard(_Tp& __x) 268 : _M_guarded(__builtin_addressof(__x)), _M_tmp(std::move(__x)) // nothrow 269 { std::destroy_at(_M_guarded); } 270 271 constexpr 272 ~_Guard() 273 { 274 if (_M_guarded) [[unlikely]] 275 std::construct_at(_M_guarded, std::move(_M_tmp)); 276 } 277 278 _Guard(const _Guard&) = delete; 279 _Guard& operator=(const _Guard&) = delete; 280 281 constexpr _Tp&& 282 release() noexcept 283 { 284 _M_guarded = nullptr; 285 return std::move(_M_tmp); 286 } 287 288 private: 289 _Tp* _M_guarded; 290 _Tp _M_tmp; 291 }; 292 293 // reinit-expected helper from [expected.object.assign] 294 template<typename _Tp, typename _Up, typename _Vp> 295 constexpr void 296 __reinit(_Tp* __newval, _Up* __oldval, _Vp&& __arg) 297 noexcept(is_nothrow_constructible_v<_Tp, _Vp>) 298 { 299 if constexpr (is_nothrow_constructible_v<_Tp, _Vp>) 300 { 301 std::destroy_at(__oldval); 302 std::construct_at(__newval, std::forward<_Vp>(__arg)); 303 } 304 else if constexpr (is_nothrow_move_constructible_v<_Tp>) 305 { 306 _Tp __tmp(std::forward<_Vp>(__arg)); // might throw 307 std::destroy_at(__oldval); 308 std::construct_at(__newval, std::move(__tmp)); 309 } 310 else 311 { 312 _Guard<_Up> __guard(*__oldval); 313 std::construct_at(__newval, std::forward<_Vp>(__arg)); // might throw 314 __guard.release(); 315 } 316 } 317 } 318 /// @endcond 319 320 template<typename _Tp, typename _Er> 321 class expected 322 { 323 static_assert( ! is_reference_v<_Tp> ); 324 static_assert( ! is_function_v<_Tp> ); 325 static_assert( ! is_same_v<remove_cv_t<_Tp>, in_place_t> ); 326 static_assert( ! is_same_v<remove_cv_t<_Tp>, unexpect_t> ); 327 static_assert( ! __expected::__is_unexpected<remove_cv_t<_Tp>> ); 328 static_assert( __expected::__can_be_unexpected<_Er> ); 329 330 template<typename _Up, typename _Err, typename _Unex = unexpected<_Er>> 331 static constexpr bool __cons_from_expected 332 = __or_v<is_constructible<_Tp, expected<_Up, _Err>&>, 333 is_constructible<_Tp, expected<_Up, _Err>>, 334 is_constructible<_Tp, const expected<_Up, _Err>&>, 335 is_constructible<_Tp, const expected<_Up, _Err>>, 336 is_convertible<expected<_Up, _Err>&, _Tp>, 337 is_convertible<expected<_Up, _Err>, _Tp>, 338 is_convertible<const expected<_Up, _Err>&, _Tp>, 339 is_convertible<const expected<_Up, _Err>, _Tp>, 340 is_constructible<_Unex, expected<_Up, _Err>&>, 341 is_constructible<_Unex, expected<_Up, _Err>>, 342 is_constructible<_Unex, const expected<_Up, _Err>&>, 343 is_constructible<_Unex, const expected<_Up, _Err>> 344 >; 345 346 template<typename _Up, typename _Err> 347 constexpr static bool __explicit_conv 348 = __or_v<__not_<is_convertible<_Up, _Tp>>, 349 __not_<is_convertible<_Err, _Er>> 350 >; 351 352 template<typename _Up> 353 static constexpr bool __same_val 354 = is_same_v<typename _Up::value_type, _Tp>; 355 356 template<typename _Up> 357 static constexpr bool __same_err 358 = is_same_v<typename _Up::error_type, _Er>; 359 360 public: 361 using value_type = _Tp; 362 using error_type = _Er; 363 using unexpected_type = unexpected<_Er>; 364 365 template<typename _Up> 366 using rebind = expected<_Up, error_type>; 367 368 constexpr 369 expected() 370 noexcept(is_nothrow_default_constructible_v<_Tp>) 371 requires is_default_constructible_v<_Tp> 372 : _M_val(), _M_has_value(true) 373 { } 374 375 expected(const expected&) = default; 376 377 constexpr 378 expected(const expected& __x) 379 noexcept(__and_v<is_nothrow_copy_constructible<_Tp>, 380 is_nothrow_copy_constructible<_Er>>) 381 requires is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Er> 382 && (!is_trivially_copy_constructible_v<_Tp> 383 || !is_trivially_copy_constructible_v<_Er>) 384 : _M_has_value(__x._M_has_value) 385 { 386 if (_M_has_value) 387 std::construct_at(__builtin_addressof(_M_val), __x._M_val); 388 else 389 std::construct_at(__builtin_addressof(_M_unex), __x._M_unex); 390 } 391 392 expected(expected&&) = default; 393 394 constexpr 395 expected(expected&& __x) 396 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 397 is_nothrow_move_constructible<_Er>>) 398 requires is_move_constructible_v<_Tp> && is_move_constructible_v<_Er> 399 && (!is_trivially_move_constructible_v<_Tp> 400 || !is_trivially_move_constructible_v<_Er>) 401 : _M_has_value(__x._M_has_value) 402 { 403 if (_M_has_value) 404 std::construct_at(__builtin_addressof(_M_val), 405 std::move(__x)._M_val); 406 else 407 std::construct_at(__builtin_addressof(_M_unex), 408 std::move(__x)._M_unex); 409 } 410 411 template<typename _Up, typename _Gr> 412 requires is_constructible_v<_Tp, const _Up&> 413 && is_constructible_v<_Er, const _Gr&> 414 && (!__cons_from_expected<_Up, _Gr>) 415 constexpr explicit(__explicit_conv<const _Up&, const _Gr&>) 416 expected(const expected<_Up, _Gr>& __x) 417 noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>, 418 is_nothrow_constructible<_Er, const _Gr&>>) 419 : _M_has_value(__x._M_has_value) 420 { 421 if (_M_has_value) 422 std::construct_at(__builtin_addressof(_M_val), __x._M_val); 423 else 424 std::construct_at(__builtin_addressof(_M_unex), __x._M_unex); 425 } 426 427 template<typename _Up, typename _Gr> 428 requires is_constructible_v<_Tp, _Up> 429 && is_constructible_v<_Er, _Gr> 430 && (!__cons_from_expected<_Up, _Gr>) 431 constexpr explicit(__explicit_conv<_Up, _Gr>) 432 expected(expected<_Up, _Gr>&& __x) 433 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>, 434 is_nothrow_constructible<_Er, _Gr>>) 435 : _M_has_value(__x._M_has_value) 436 { 437 if (_M_has_value) 438 std::construct_at(__builtin_addressof(_M_val), 439 std::move(__x)._M_val); 440 else 441 std::construct_at(__builtin_addressof(_M_unex), 442 std::move(__x)._M_unex); 443 } 444 445 template<typename _Up = _Tp> 446 requires (!is_same_v<remove_cvref_t<_Up>, expected>) 447 && (!is_same_v<remove_cvref_t<_Up>, in_place_t>) 448 && (!__expected::__is_unexpected<remove_cvref_t<_Up>>) 449 && is_constructible_v<_Tp, _Up> 450 constexpr explicit(!is_convertible_v<_Up, _Tp>) 451 expected(_Up&& __v) 452 noexcept(is_nothrow_constructible_v<_Tp, _Up>) 453 : _M_val(std::forward<_Up>(__v)), _M_has_value(true) 454 { } 455 456 template<typename _Gr = _Er> 457 requires is_constructible_v<_Er, const _Gr&> 458 constexpr explicit(!is_convertible_v<const _Gr&, _Er>) 459 expected(const unexpected<_Gr>& __u) 460 noexcept(is_nothrow_constructible_v<_Er, const _Gr&>) 461 : _M_unex(__u.error()), _M_has_value(false) 462 { } 463 464 template<typename _Gr = _Er> 465 requires is_constructible_v<_Er, _Gr> 466 constexpr explicit(!is_convertible_v<_Gr, _Er>) 467 expected(unexpected<_Gr>&& __u) 468 noexcept(is_nothrow_constructible_v<_Er, _Gr>) 469 : _M_unex(std::move(__u).error()), _M_has_value(false) 470 { } 471 472 template<typename... _Args> 473 requires is_constructible_v<_Tp, _Args...> 474 constexpr explicit 475 expected(in_place_t, _Args&&... __args) 476 noexcept(is_nothrow_constructible_v<_Tp, _Args...>) 477 : _M_val(std::forward<_Args>(__args)...), _M_has_value(true) 478 { } 479 480 template<typename _Up, typename... _Args> 481 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...> 482 constexpr explicit 483 expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 484 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, 485 _Args...>) 486 : _M_val(__il, std::forward<_Args>(__args)...), _M_has_value(true) 487 { } 488 489 template<typename... _Args> 490 requires is_constructible_v<_Er, _Args...> 491 constexpr explicit 492 expected(unexpect_t, _Args&&... __args) 493 noexcept(is_nothrow_constructible_v<_Er, _Args...>) 494 : _M_unex(std::forward<_Args>(__args)...), _M_has_value(false) 495 { } 496 497 template<typename _Up, typename... _Args> 498 requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...> 499 constexpr explicit 500 expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) 501 noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&, 502 _Args...>) 503 : _M_unex(__il, std::forward<_Args>(__args)...), _M_has_value(false) 504 { } 505 506 constexpr ~expected() = default; 507 508 constexpr ~expected() 509 requires (!is_trivially_destructible_v<_Tp>) 510 || (!is_trivially_destructible_v<_Er>) 511 { 512 if (_M_has_value) 513 std::destroy_at(__builtin_addressof(_M_val)); 514 else 515 std::destroy_at(__builtin_addressof(_M_unex)); 516 } 517 518 // assignment 519 520 expected& operator=(const expected&) = delete; 521 522 constexpr expected& 523 operator=(const expected& __x) 524 noexcept(__and_v<is_nothrow_copy_constructible<_Tp>, 525 is_nothrow_copy_constructible<_Er>, 526 is_nothrow_copy_assignable<_Tp>, 527 is_nothrow_copy_assignable<_Er>>) 528 requires is_copy_assignable_v<_Tp> && is_copy_constructible_v<_Tp> 529 && is_copy_assignable_v<_Er> && is_copy_constructible_v<_Er> 530 && (is_nothrow_move_constructible_v<_Tp> 531 || is_nothrow_move_constructible_v<_Er>) 532 { 533 if (__x._M_has_value) 534 this->_M_assign_val(__x._M_val); 535 else 536 this->_M_assign_unex(__x._M_unex); 537 return *this; 538 } 539 540 constexpr expected& 541 operator=(expected&& __x) 542 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 543 is_nothrow_move_constructible<_Er>, 544 is_nothrow_move_assignable<_Tp>, 545 is_nothrow_move_assignable<_Er>>) 546 requires is_move_assignable_v<_Tp> && is_move_constructible_v<_Tp> 547 && is_move_assignable_v<_Er> && is_move_constructible_v<_Er> 548 && (is_nothrow_move_constructible_v<_Tp> 549 || is_nothrow_move_constructible_v<_Er>) 550 { 551 if (__x._M_has_value) 552 _M_assign_val(std::move(__x._M_val)); 553 else 554 _M_assign_unex(std::move(__x._M_unex)); 555 return *this; 556 } 557 558 template<typename _Up = _Tp> 559 requires (!is_same_v<expected, remove_cvref_t<_Up>>) 560 && (!__expected::__is_unexpected<remove_cvref_t<_Up>>) 561 && is_constructible_v<_Tp, _Up> && is_assignable_v<_Tp&, _Up> 562 && (is_nothrow_constructible_v<_Tp, _Up> 563 || is_nothrow_move_constructible_v<_Tp> 564 || is_nothrow_move_constructible_v<_Er>) 565 constexpr expected& 566 operator=(_Up&& __v) 567 { 568 _M_assign_val(std::forward<_Up>(__v)); 569 return *this; 570 } 571 572 template<typename _Gr> 573 requires is_constructible_v<_Er, const _Gr&> 574 && is_assignable_v<_Er&, const _Gr&> 575 && (is_nothrow_constructible_v<_Er, const _Gr&> 576 || is_nothrow_move_constructible_v<_Tp> 577 || is_nothrow_move_constructible_v<_Er>) 578 constexpr expected& 579 operator=(const unexpected<_Gr>& __e) 580 { 581 _M_assign_unex(__e.error()); 582 return *this; 583 } 584 585 template<typename _Gr> 586 requires is_constructible_v<_Er, _Gr> 587 && is_assignable_v<_Er&, _Gr> 588 && (is_nothrow_constructible_v<_Er, _Gr> 589 || is_nothrow_move_constructible_v<_Tp> 590 || is_nothrow_move_constructible_v<_Er>) 591 constexpr expected& 592 operator=(unexpected<_Gr>&& __e) 593 { 594 _M_assign_unex(std::move(__e).error()); 595 return *this; 596 } 597 598 // modifiers 599 600 template<typename... _Args> 601 requires is_nothrow_constructible_v<_Tp, _Args...> 602 constexpr _Tp& 603 emplace(_Args&&... __args) noexcept 604 { 605 if (_M_has_value) 606 std::destroy_at(__builtin_addressof(_M_val)); 607 else 608 { 609 std::destroy_at(__builtin_addressof(_M_unex)); 610 _M_has_value = true; 611 } 612 std::construct_at(__builtin_addressof(_M_val), 613 std::forward<_Args>(__args)...); 614 return _M_val; 615 } 616 617 template<typename _Up, typename... _Args> 618 requires is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, 619 _Args...> 620 constexpr _Tp& 621 emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept 622 { 623 if (_M_has_value) 624 std::destroy_at(__builtin_addressof(_M_val)); 625 else 626 { 627 std::destroy_at(__builtin_addressof(_M_unex)); 628 _M_has_value = true; 629 } 630 std::construct_at(__builtin_addressof(_M_val), 631 __il, std::forward<_Args>(__args)...); 632 return _M_val; 633 } 634 635 // swap 636 constexpr void 637 swap(expected& __x) 638 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 639 is_nothrow_move_constructible<_Er>, 640 is_nothrow_swappable<_Tp&>, 641 is_nothrow_swappable<_Er&>>) 642 requires is_swappable_v<_Tp> && is_swappable_v<_Er> 643 && is_move_constructible_v<_Tp> 644 && is_move_constructible_v<_Er> 645 && (is_nothrow_move_constructible_v<_Tp> 646 || is_nothrow_move_constructible_v<_Er>) 647 { 648 if (_M_has_value) 649 { 650 if (__x._M_has_value) 651 { 652 using std::swap; 653 swap(_M_val, __x._M_val); 654 } 655 else 656 this->_M_swap_val_unex(__x); 657 } 658 else 659 { 660 if (__x._M_has_value) 661 __x._M_swap_val_unex(*this); 662 else 663 { 664 using std::swap; 665 swap(_M_unex, __x._M_unex); 666 } 667 } 668 } 669 670 // observers 671 672 [[nodiscard]] 673 constexpr const _Tp* 674 operator->() const noexcept 675 { 676 __glibcxx_assert(_M_has_value); 677 return __builtin_addressof(_M_val); 678 } 679 680 [[nodiscard]] 681 constexpr _Tp* 682 operator->() noexcept 683 { 684 __glibcxx_assert(_M_has_value); 685 return __builtin_addressof(_M_val); 686 } 687 688 [[nodiscard]] 689 constexpr const _Tp& 690 operator*() const & noexcept 691 { 692 __glibcxx_assert(_M_has_value); 693 return _M_val; 694 } 695 696 [[nodiscard]] 697 constexpr _Tp& 698 operator*() & noexcept 699 { 700 __glibcxx_assert(_M_has_value); 701 return _M_val; 702 } 703 704 [[nodiscard]] 705 constexpr const _Tp&& 706 operator*() const && noexcept 707 { 708 __glibcxx_assert(_M_has_value); 709 return std::move(_M_val); 710 } 711 712 [[nodiscard]] 713 constexpr _Tp&& 714 operator*() && noexcept 715 { 716 __glibcxx_assert(_M_has_value); 717 return std::move(_M_val); 718 } 719 720 [[nodiscard]] 721 constexpr explicit 722 operator bool() const noexcept { return _M_has_value; } 723 724 [[nodiscard]] 725 constexpr bool has_value() const noexcept { return _M_has_value; } 726 727 constexpr const _Tp& 728 value() const & 729 { 730 if (_M_has_value) [[likely]] 731 return _M_val; 732 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(_M_unex)); 733 } 734 735 constexpr _Tp& 736 value() & 737 { 738 if (_M_has_value) [[likely]] 739 return _M_val; 740 const auto& __unex = _M_unex; 741 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(__unex)); 742 } 743 744 constexpr const _Tp&& 745 value() const && 746 { 747 if (_M_has_value) [[likely]] 748 return std::move(_M_val); 749 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(std::move(_M_unex))); 750 } 751 752 constexpr _Tp&& 753 value() && 754 { 755 if (_M_has_value) [[likely]] 756 return std::move(_M_val); 757 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(std::move(_M_unex))); 758 } 759 760 constexpr const _Er& 761 error() const & noexcept 762 { 763 __glibcxx_assert(!_M_has_value); 764 return _M_unex; 765 } 766 767 constexpr _Er& 768 error() & noexcept 769 { 770 __glibcxx_assert(!_M_has_value); 771 return _M_unex; 772 } 773 774 constexpr const _Er&& 775 error() const && noexcept 776 { 777 __glibcxx_assert(!_M_has_value); 778 return std::move(_M_unex); 779 } 780 781 constexpr _Er&& 782 error() && noexcept 783 { 784 __glibcxx_assert(!_M_has_value); 785 return std::move(_M_unex); 786 } 787 788 template<typename _Up> 789 constexpr _Tp 790 value_or(_Up&& __v) const & 791 noexcept(__and_v<is_nothrow_copy_constructible<_Tp>, 792 is_nothrow_convertible<_Up, _Tp>>) 793 { 794 static_assert( is_copy_constructible_v<_Tp> ); 795 static_assert( is_convertible_v<_Up, _Tp> ); 796 797 if (_M_has_value) 798 return _M_val; 799 return static_cast<_Tp>(std::forward<_Up>(__v)); 800 } 801 802 template<typename _Up> 803 constexpr _Tp 804 value_or(_Up&& __v) && 805 noexcept(__and_v<is_nothrow_move_constructible<_Tp>, 806 is_nothrow_convertible<_Up, _Tp>>) 807 { 808 static_assert( is_move_constructible_v<_Tp> ); 809 static_assert( is_convertible_v<_Up, _Tp> ); 810 811 if (_M_has_value) 812 return std::move(_M_val); 813 return static_cast<_Tp>(std::forward<_Up>(__v)); 814 } 815 816 template<typename _Gr = _Er> 817 constexpr _Er 818 error_or(_Gr&& __e) const& 819 { 820 static_assert( is_copy_constructible_v<_Er> ); 821 static_assert( is_convertible_v<_Gr, _Er> ); 822 823 if (_M_has_value) 824 return std::forward<_Gr>(__e); 825 return _M_unex; 826 } 827 828 template<typename _Gr = _Er> 829 constexpr _Er 830 error_or(_Gr&& __e) && 831 { 832 static_assert( is_move_constructible_v<_Er> ); 833 static_assert( is_convertible_v<_Gr, _Er> ); 834 835 if (_M_has_value) 836 return std::forward<_Gr>(__e); 837 return std::move(_M_unex); 838 } 839 840 // monadic operations 841 842 template<typename _Fn> requires is_constructible_v<_Er, _Er&> 843 constexpr auto 844 and_then(_Fn&& __f) & 845 { 846 using _Up = __expected::__result<_Fn, _Tp&>; 847 static_assert(__expected::__is_expected<_Up>, 848 "the function passed to std::expected<T, E>::and_then " 849 "must return a std::expected"); 850 static_assert(is_same_v<typename _Up::error_type, _Er>, 851 "the function passed to std::expected<T, E>::and_then " 852 "must return a std::expected with the same error_type"); 853 854 if (has_value()) 855 return std::__invoke(std::forward<_Fn>(__f), _M_val); 856 else 857 return _Up(unexpect, _M_unex); 858 } 859 860 template<typename _Fn> requires is_constructible_v<_Er, const _Er&> 861 constexpr auto 862 and_then(_Fn&& __f) const & 863 { 864 using _Up = __expected::__result<_Fn, const _Tp&>; 865 static_assert(__expected::__is_expected<_Up>, 866 "the function passed to std::expected<T, E>::and_then " 867 "must return a std::expected"); 868 static_assert(is_same_v<typename _Up::error_type, _Er>, 869 "the function passed to std::expected<T, E>::and_then " 870 "must return a std::expected with the same error_type"); 871 872 if (has_value()) 873 return std::__invoke(std::forward<_Fn>(__f), _M_val); 874 else 875 return _Up(unexpect, _M_unex); 876 } 877 878 template<typename _Fn> requires is_constructible_v<_Er, _Er> 879 constexpr auto 880 and_then(_Fn&& __f) && 881 { 882 using _Up = __expected::__result<_Fn, _Tp&&>; 883 static_assert(__expected::__is_expected<_Up>, 884 "the function passed to std::expected<T, E>::and_then " 885 "must return a std::expected"); 886 static_assert(is_same_v<typename _Up::error_type, _Er>, 887 "the function passed to std::expected<T, E>::and_then " 888 "must return a std::expected with the same error_type"); 889 890 if (has_value()) 891 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_val)); 892 else 893 return _Up(unexpect, std::move(_M_unex)); 894 } 895 896 897 template<typename _Fn> requires is_constructible_v<_Er, const _Er> 898 constexpr auto 899 and_then(_Fn&& __f) const && 900 { 901 using _Up = __expected::__result<_Fn, const _Tp&&>; 902 static_assert(__expected::__is_expected<_Up>, 903 "the function passed to std::expected<T, E>::and_then " 904 "must return a std::expected"); 905 static_assert(is_same_v<typename _Up::error_type, _Er>, 906 "the function passed to std::expected<T, E>::and_then " 907 "must return a std::expected with the same error_type"); 908 909 if (has_value()) 910 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_val)); 911 else 912 return _Up(unexpect, std::move(_M_unex)); 913 } 914 915 template<typename _Fn> requires is_constructible_v<_Tp, _Tp&> 916 constexpr auto 917 or_else(_Fn&& __f) & 918 { 919 using _Gr = __expected::__result<_Fn, _Er&>; 920 static_assert(__expected::__is_expected<_Gr>, 921 "the function passed to std::expected<T, E>::or_else " 922 "must return a std::expected"); 923 static_assert(is_same_v<typename _Gr::value_type, _Tp>, 924 "the function passed to std::expected<T, E>::or_else " 925 "must return a std::expected with the same value_type"); 926 927 if (has_value()) 928 return _Gr(in_place, _M_val); 929 else 930 return std::__invoke(std::forward<_Fn>(__f), _M_unex); 931 } 932 933 template<typename _Fn> requires is_constructible_v<_Tp, const _Tp&> 934 constexpr auto 935 or_else(_Fn&& __f) const & 936 { 937 using _Gr = __expected::__result<_Fn, const _Er&>; 938 static_assert(__expected::__is_expected<_Gr>, 939 "the function passed to std::expected<T, E>::or_else " 940 "must return a std::expected"); 941 static_assert(is_same_v<typename _Gr::value_type, _Tp>, 942 "the function passed to std::expected<T, E>::or_else " 943 "must return a std::expected with the same value_type"); 944 945 if (has_value()) 946 return _Gr(in_place, _M_val); 947 else 948 return std::__invoke(std::forward<_Fn>(__f), _M_unex); 949 } 950 951 952 template<typename _Fn> requires is_constructible_v<_Tp, _Tp> 953 constexpr auto 954 or_else(_Fn&& __f) && 955 { 956 using _Gr = __expected::__result<_Fn, _Er&&>; 957 static_assert(__expected::__is_expected<_Gr>, 958 "the function passed to std::expected<T, E>::or_else " 959 "must return a std::expected"); 960 static_assert(is_same_v<typename _Gr::value_type, _Tp>, 961 "the function passed to std::expected<T, E>::or_else " 962 "must return a std::expected with the same value_type"); 963 964 if (has_value()) 965 return _Gr(in_place, std::move(_M_val)); 966 else 967 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_unex)); 968 } 969 970 template<typename _Fn> requires is_constructible_v<_Tp, const _Tp> 971 constexpr auto 972 or_else(_Fn&& __f) const && 973 { 974 using _Gr = __expected::__result<_Fn, const _Er&&>; 975 static_assert(__expected::__is_expected<_Gr>, 976 "the function passed to std::expected<T, E>::or_else " 977 "must return a std::expected"); 978 static_assert(is_same_v<typename _Gr::value_type, _Tp>, 979 "the function passed to std::expected<T, E>::or_else " 980 "must return a std::expected with the same value_type"); 981 982 if (has_value()) 983 return _Gr(in_place, std::move(_M_val)); 984 else 985 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_unex)); 986 } 987 988 template<typename _Fn> requires is_constructible_v<_Er, _Er&> 989 constexpr auto 990 transform(_Fn&& __f) & 991 { 992 using _Up = __expected::__result_xform<_Fn, _Tp&>; 993 using _Res = expected<_Up, _Er>; 994 995 if (has_value()) 996 return _Res(__in_place_inv{}, [&]() { 997 return std::__invoke(std::forward<_Fn>(__f), 998 _M_val); 999 }); 1000 else 1001 return _Res(unexpect, _M_unex); 1002 } 1003 1004 template<typename _Fn> requires is_constructible_v<_Er, const _Er&> 1005 constexpr auto 1006 transform(_Fn&& __f) const & 1007 { 1008 using _Up = __expected::__result_xform<_Fn, const _Tp&>; 1009 using _Res = expected<_Up, _Er>; 1010 1011 if (has_value()) 1012 return _Res(__in_place_inv{}, [&]() { 1013 return std::__invoke(std::forward<_Fn>(__f), 1014 _M_val); 1015 }); 1016 else 1017 return _Res(unexpect, _M_unex); 1018 } 1019 1020 template<typename _Fn> requires is_constructible_v<_Er, _Er> 1021 constexpr auto 1022 transform(_Fn&& __f) && 1023 { 1024 using _Up = __expected::__result_xform<_Fn, _Tp>; 1025 using _Res = expected<_Up, _Er>; 1026 1027 if (has_value()) 1028 return _Res(__in_place_inv{}, [&]() { 1029 return std::__invoke(std::forward<_Fn>(__f), 1030 std::move(_M_val)); 1031 }); 1032 else 1033 return _Res(unexpect, std::move(_M_unex)); 1034 } 1035 1036 template<typename _Fn> requires is_constructible_v<_Er, const _Er> 1037 constexpr auto 1038 transform(_Fn&& __f) const && 1039 { 1040 using _Up = __expected::__result_xform<_Fn, const _Tp>; 1041 using _Res = expected<_Up, _Er>; 1042 1043 if (has_value()) 1044 return _Res(__in_place_inv{}, [&]() { 1045 return std::__invoke(std::forward<_Fn>(__f), 1046 std::move(_M_val)); 1047 }); 1048 else 1049 return _Res(unexpect, std::move(_M_unex)); 1050 } 1051 1052 template<typename _Fn> requires is_constructible_v<_Tp, _Tp&> 1053 constexpr auto 1054 transform_error(_Fn&& __f) & 1055 { 1056 using _Gr = __expected::__result_xform<_Fn, _Er&>; 1057 using _Res = expected<_Tp, _Gr>; 1058 1059 if (has_value()) 1060 return _Res(in_place, _M_val); 1061 else 1062 return _Res(__unexpect_inv{}, [&]() { 1063 return std::__invoke(std::forward<_Fn>(__f), 1064 _M_unex); 1065 }); 1066 } 1067 1068 template<typename _Fn> requires is_constructible_v<_Tp, const _Tp&> 1069 constexpr auto 1070 transform_error(_Fn&& __f) const & 1071 { 1072 using _Gr = __expected::__result_xform<_Fn, const _Er&>; 1073 using _Res = expected<_Tp, _Gr>; 1074 1075 if (has_value()) 1076 return _Res(in_place, _M_val); 1077 else 1078 return _Res(__unexpect_inv{}, [&]() { 1079 return std::__invoke(std::forward<_Fn>(__f), 1080 _M_unex); 1081 }); 1082 } 1083 1084 template<typename _Fn> requires is_constructible_v<_Tp, _Tp> 1085 constexpr auto 1086 transform_error(_Fn&& __f) && 1087 { 1088 using _Gr = __expected::__result_xform<_Fn, _Er&&>; 1089 using _Res = expected<_Tp, _Gr>; 1090 1091 if (has_value()) 1092 return _Res(in_place, std::move(_M_val)); 1093 else 1094 return _Res(__unexpect_inv{}, [&]() { 1095 return std::__invoke(std::forward<_Fn>(__f), 1096 std::move(_M_unex)); 1097 }); 1098 } 1099 1100 template<typename _Fn> requires is_constructible_v<_Tp, const _Tp> 1101 constexpr auto 1102 transform_error(_Fn&& __f) const && 1103 { 1104 using _Gr = __expected::__result_xform<_Fn, const _Er&&>; 1105 using _Res = expected<_Tp, _Gr>; 1106 1107 if (has_value()) 1108 return _Res(in_place, std::move(_M_val)); 1109 else 1110 return _Res(__unexpect_inv{}, [&]() { 1111 return std::__invoke(std::forward<_Fn>(__f), 1112 std::move(_M_unex)); 1113 }); 1114 } 1115 1116 // equality operators 1117 1118 template<typename _Up, typename _Er2> 1119 requires (!is_void_v<_Up>) 1120 friend constexpr bool 1121 operator==(const expected& __x, const expected<_Up, _Er2>& __y) 1122 // FIXME: noexcept(noexcept(bool(*__x == *__y)) 1123 // && noexcept(bool(__x.error() == __y.error()))) 1124 { 1125 if (__x.has_value()) 1126 return __y.has_value() && bool(*__x == *__y); 1127 else 1128 return !__y.has_value() && bool(__x.error() == __y.error()); 1129 } 1130 1131 template<typename _Up> 1132 friend constexpr bool 1133 operator==(const expected& __x, const _Up& __v) 1134 // FIXME: noexcept(noexcept(bool(*__x == __v))) 1135 { return __x.has_value() && bool(*__x == __v); } 1136 1137 template<typename _Er2> 1138 friend constexpr bool 1139 operator==(const expected& __x, const unexpected<_Er2>& __e) 1140 // FIXME: noexcept(noexcept(bool(__x.error() == __e.error()))) 1141 { return !__x.has_value() && bool(__x.error() == __e.error()); } 1142 1143 friend constexpr void 1144 swap(expected& __x, expected& __y) 1145 noexcept(noexcept(__x.swap(__y))) 1146 requires requires {__x.swap(__y);} 1147 { __x.swap(__y); } 1148 1149 private: 1150 template<typename, typename> friend class expected; 1151 1152 template<typename _Vp> 1153 constexpr void 1154 _M_assign_val(_Vp&& __v) 1155 { 1156 if (_M_has_value) 1157 _M_val = std::forward<_Vp>(__v); 1158 else 1159 { 1160 __expected::__reinit(__builtin_addressof(_M_val), 1161 __builtin_addressof(_M_unex), 1162 std::forward<_Vp>(__v)); 1163 _M_has_value = true; 1164 } 1165 } 1166 1167 template<typename _Vp> 1168 constexpr void 1169 _M_assign_unex(_Vp&& __v) 1170 { 1171 if (_M_has_value) 1172 { 1173 __expected::__reinit(__builtin_addressof(_M_unex), 1174 __builtin_addressof(_M_val), 1175 std::forward<_Vp>(__v)); 1176 _M_has_value = false; 1177 } 1178 else 1179 _M_unex = std::forward<_Vp>(__v); 1180 } 1181 1182 // Swap two expected objects when only one has a value. 1183 // Precondition: this->_M_has_value && !__rhs._M_has_value 1184 constexpr void 1185 _M_swap_val_unex(expected& __rhs) 1186 noexcept(__and_v<is_nothrow_move_constructible<_Er>, 1187 is_nothrow_move_constructible<_Tp>>) 1188 { 1189 if constexpr (is_nothrow_move_constructible_v<_Er>) 1190 { 1191 __expected::_Guard<_Er> __guard(__rhs._M_unex); 1192 std::construct_at(__builtin_addressof(__rhs._M_val), 1193 std::move(_M_val)); // might throw 1194 __rhs._M_has_value = true; 1195 std::destroy_at(__builtin_addressof(_M_val)); 1196 std::construct_at(__builtin_addressof(_M_unex), 1197 __guard.release()); 1198 _M_has_value = false; 1199 } 1200 else 1201 { 1202 __expected::_Guard<_Tp> __guard(_M_val); 1203 std::construct_at(__builtin_addressof(_M_unex), 1204 std::move(__rhs._M_unex)); // might throw 1205 _M_has_value = false; 1206 std::destroy_at(__builtin_addressof(__rhs._M_unex)); 1207 std::construct_at(__builtin_addressof(__rhs._M_val), 1208 __guard.release()); 1209 __rhs._M_has_value = true; 1210 } 1211 } 1212 1213 using __in_place_inv = __expected::__in_place_inv; 1214 using __unexpect_inv = __expected::__unexpect_inv; 1215 1216 template<typename _Fn> 1217 explicit constexpr 1218 expected(__in_place_inv, _Fn&& __fn) 1219 : _M_val(std::forward<_Fn>(__fn)()), _M_has_value(true) 1220 { } 1221 1222 template<typename _Fn> 1223 explicit constexpr 1224 expected(__unexpect_inv, _Fn&& __fn) 1225 : _M_unex(std::forward<_Fn>(__fn)()), _M_has_value(false) 1226 { } 1227 1228 union { 1229 _Tp _M_val; 1230 _Er _M_unex; 1231 }; 1232 1233 bool _M_has_value; 1234 }; 1235 1236 // Partial specialization for std::expected<cv void, E> 1237 template<typename _Tp, typename _Er> requires is_void_v<_Tp> 1238 class expected<_Tp, _Er> 1239 { 1240 static_assert( __expected::__can_be_unexpected<_Er> ); 1241 1242 template<typename _Up, typename _Err, typename _Unex = unexpected<_Er>> 1243 static constexpr bool __cons_from_expected 1244 = __or_v<is_constructible<_Unex, expected<_Up, _Err>&>, 1245 is_constructible<_Unex, expected<_Up, _Err>>, 1246 is_constructible<_Unex, const expected<_Up, _Err>&>, 1247 is_constructible<_Unex, const expected<_Up, _Err>> 1248 >; 1249 1250 template<typename _Up> 1251 static constexpr bool __same_val 1252 = is_same_v<typename _Up::value_type, _Tp>; 1253 1254 template<typename _Up> 1255 static constexpr bool __same_err 1256 = is_same_v<typename _Up::error_type, _Er>; 1257 1258 public: 1259 using value_type = _Tp; 1260 using error_type = _Er; 1261 using unexpected_type = unexpected<_Er>; 1262 1263 template<typename _Up> 1264 using rebind = expected<_Up, error_type>; 1265 1266 constexpr 1267 expected() noexcept 1268 : _M_void(), _M_has_value(true) 1269 { } 1270 1271 expected(const expected&) = default; 1272 1273 constexpr 1274 expected(const expected& __x) 1275 noexcept(is_nothrow_copy_constructible_v<_Er>) 1276 requires is_copy_constructible_v<_Er> 1277 && (!is_trivially_copy_constructible_v<_Er>) 1278 : _M_void(), _M_has_value(__x._M_has_value) 1279 { 1280 if (!_M_has_value) 1281 std::construct_at(__builtin_addressof(_M_unex), __x._M_unex); 1282 } 1283 1284 expected(expected&&) = default; 1285 1286 constexpr 1287 expected(expected&& __x) 1288 noexcept(is_nothrow_move_constructible_v<_Er>) 1289 requires is_move_constructible_v<_Er> 1290 && (!is_trivially_move_constructible_v<_Er>) 1291 : _M_void(), _M_has_value(__x._M_has_value) 1292 { 1293 if (!_M_has_value) 1294 std::construct_at(__builtin_addressof(_M_unex), 1295 std::move(__x)._M_unex); 1296 } 1297 1298 template<typename _Up, typename _Gr> 1299 requires is_void_v<_Up> 1300 && is_constructible_v<_Er, const _Gr&> 1301 && (!__cons_from_expected<_Up, _Gr>) 1302 constexpr explicit(!is_convertible_v<const _Gr&, _Er>) 1303 expected(const expected<_Up, _Gr>& __x) 1304 noexcept(is_nothrow_constructible_v<_Er, const _Gr&>) 1305 : _M_void(), _M_has_value(__x._M_has_value) 1306 { 1307 if (!_M_has_value) 1308 std::construct_at(__builtin_addressof(_M_unex), __x._M_unex); 1309 } 1310 1311 template<typename _Up, typename _Gr> 1312 requires is_void_v<_Up> 1313 && is_constructible_v<_Er, _Gr> 1314 && (!__cons_from_expected<_Up, _Gr>) 1315 constexpr explicit(!is_convertible_v<_Gr, _Er>) 1316 expected(expected<_Up, _Gr>&& __x) 1317 noexcept(is_nothrow_constructible_v<_Er, _Gr>) 1318 : _M_void(), _M_has_value(__x._M_has_value) 1319 { 1320 if (!_M_has_value) 1321 std::construct_at(__builtin_addressof(_M_unex), 1322 std::move(__x)._M_unex); 1323 } 1324 1325 template<typename _Gr = _Er> 1326 requires is_constructible_v<_Er, const _Gr&> 1327 constexpr explicit(!is_convertible_v<const _Gr&, _Er>) 1328 expected(const unexpected<_Gr>& __u) 1329 noexcept(is_nothrow_constructible_v<_Er, const _Gr&>) 1330 : _M_unex(__u.error()), _M_has_value(false) 1331 { } 1332 1333 template<typename _Gr = _Er> 1334 requires is_constructible_v<_Er, _Gr> 1335 constexpr explicit(!is_convertible_v<_Gr, _Er>) 1336 expected(unexpected<_Gr>&& __u) 1337 noexcept(is_nothrow_constructible_v<_Er, _Gr>) 1338 : _M_unex(std::move(__u).error()), _M_has_value(false) 1339 { } 1340 1341 constexpr explicit 1342 expected(in_place_t) noexcept 1343 : expected() 1344 { } 1345 1346 template<typename... _Args> 1347 requires is_constructible_v<_Er, _Args...> 1348 constexpr explicit 1349 expected(unexpect_t, _Args&&... __args) 1350 noexcept(is_nothrow_constructible_v<_Er, _Args...>) 1351 : _M_unex(std::forward<_Args>(__args)...), _M_has_value(false) 1352 { } 1353 1354 template<typename _Up, typename... _Args> 1355 requires is_constructible_v<_Er, initializer_list<_Up>&, _Args...> 1356 constexpr explicit 1357 expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) 1358 noexcept(is_nothrow_constructible_v<_Er, initializer_list<_Up>&, 1359 _Args...>) 1360 : _M_unex(__il, std::forward<_Args>(__args)...), _M_has_value(false) 1361 { } 1362 1363 constexpr ~expected() = default; 1364 1365 constexpr ~expected() requires (!is_trivially_destructible_v<_Er>) 1366 { 1367 if (!_M_has_value) 1368 std::destroy_at(__builtin_addressof(_M_unex)); 1369 } 1370 1371 // assignment 1372 1373 expected& operator=(const expected&) = delete; 1374 1375 constexpr expected& 1376 operator=(const expected& __x) 1377 noexcept(__and_v<is_nothrow_copy_constructible<_Er>, 1378 is_nothrow_copy_assignable<_Er>>) 1379 requires is_copy_constructible_v<_Er> 1380 && is_copy_assignable_v<_Er> 1381 { 1382 if (__x._M_has_value) 1383 emplace(); 1384 else 1385 _M_assign_unex(__x._M_unex); 1386 return *this; 1387 } 1388 1389 constexpr expected& 1390 operator=(expected&& __x) 1391 noexcept(__and_v<is_nothrow_move_constructible<_Er>, 1392 is_nothrow_move_assignable<_Er>>) 1393 requires is_move_constructible_v<_Er> 1394 && is_move_assignable_v<_Er> 1395 { 1396 if (__x._M_has_value) 1397 emplace(); 1398 else 1399 _M_assign_unex(std::move(__x._M_unex)); 1400 return *this; 1401 } 1402 1403 template<typename _Gr> 1404 requires is_constructible_v<_Er, const _Gr&> 1405 && is_assignable_v<_Er&, const _Gr&> 1406 constexpr expected& 1407 operator=(const unexpected<_Gr>& __e) 1408 { 1409 _M_assign_unex(__e.error()); 1410 return *this; 1411 } 1412 1413 template<typename _Gr> 1414 requires is_constructible_v<_Er, _Gr> 1415 && is_assignable_v<_Er&, _Gr> 1416 constexpr expected& 1417 operator=(unexpected<_Gr>&& __e) 1418 { 1419 _M_assign_unex(std::move(__e.error())); 1420 return *this; 1421 } 1422 1423 // modifiers 1424 1425 constexpr void 1426 emplace() noexcept 1427 { 1428 if (!_M_has_value) 1429 { 1430 std::destroy_at(__builtin_addressof(_M_unex)); 1431 _M_has_value = true; 1432 } 1433 } 1434 1435 // swap 1436 constexpr void 1437 swap(expected& __x) 1438 noexcept(__and_v<is_nothrow_swappable<_Er&>, 1439 is_nothrow_move_constructible<_Er>>) 1440 requires is_swappable_v<_Er> && is_move_constructible_v<_Er> 1441 { 1442 if (_M_has_value) 1443 { 1444 if (!__x._M_has_value) 1445 { 1446 std::construct_at(__builtin_addressof(_M_unex), 1447 std::move(__x._M_unex)); // might throw 1448 std::destroy_at(__builtin_addressof(__x._M_unex)); 1449 _M_has_value = false; 1450 __x._M_has_value = true; 1451 } 1452 } 1453 else 1454 { 1455 if (__x._M_has_value) 1456 { 1457 std::construct_at(__builtin_addressof(__x._M_unex), 1458 std::move(_M_unex)); // might throw 1459 std::destroy_at(__builtin_addressof(_M_unex)); 1460 _M_has_value = true; 1461 __x._M_has_value = false; 1462 } 1463 else 1464 { 1465 using std::swap; 1466 swap(_M_unex, __x._M_unex); 1467 } 1468 } 1469 } 1470 1471 // observers 1472 1473 [[nodiscard]] 1474 constexpr explicit 1475 operator bool() const noexcept { return _M_has_value; } 1476 1477 [[nodiscard]] 1478 constexpr bool has_value() const noexcept { return _M_has_value; } 1479 1480 constexpr void 1481 operator*() const noexcept { __glibcxx_assert(_M_has_value); } 1482 1483 constexpr void 1484 value() const& 1485 { 1486 if (_M_has_value) [[likely]] 1487 return; 1488 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(_M_unex)); 1489 } 1490 1491 constexpr void 1492 value() && 1493 { 1494 if (_M_has_value) [[likely]] 1495 return; 1496 _GLIBCXX_THROW_OR_ABORT(bad_expected_access<_Er>(std::move(_M_unex))); 1497 } 1498 1499 constexpr const _Er& 1500 error() const & noexcept 1501 { 1502 __glibcxx_assert(!_M_has_value); 1503 return _M_unex; 1504 } 1505 1506 constexpr _Er& 1507 error() & noexcept 1508 { 1509 __glibcxx_assert(!_M_has_value); 1510 return _M_unex; 1511 } 1512 1513 constexpr const _Er&& 1514 error() const && noexcept 1515 { 1516 __glibcxx_assert(!_M_has_value); 1517 return std::move(_M_unex); 1518 } 1519 1520 constexpr _Er&& 1521 error() && noexcept 1522 { 1523 __glibcxx_assert(!_M_has_value); 1524 return std::move(_M_unex); 1525 } 1526 1527 template<typename _Gr = _Er> 1528 constexpr _Er 1529 error_or(_Gr&& __e) const& 1530 { 1531 static_assert( is_copy_constructible_v<_Er> ); 1532 static_assert( is_convertible_v<_Gr, _Er> ); 1533 1534 if (_M_has_value) 1535 return std::forward<_Gr>(__e); 1536 return _M_unex; 1537 } 1538 1539 template<typename _Gr = _Er> 1540 constexpr _Er 1541 error_or(_Gr&& __e) && 1542 { 1543 static_assert( is_move_constructible_v<_Er> ); 1544 static_assert( is_convertible_v<_Gr, _Er> ); 1545 1546 if (_M_has_value) 1547 return std::forward<_Gr>(__e); 1548 return std::move(_M_unex); 1549 } 1550 1551 // monadic operations 1552 1553 template<typename _Fn> requires is_constructible_v<_Er, _Er&> 1554 constexpr auto 1555 and_then(_Fn&& __f) & 1556 { 1557 using _Up = __expected::__result0<_Fn>; 1558 static_assert(__expected::__is_expected<_Up>); 1559 static_assert(is_same_v<typename _Up::error_type, _Er>); 1560 1561 if (has_value()) 1562 return std::__invoke(std::forward<_Fn>(__f)); 1563 else 1564 return _Up(unexpect, _M_unex); 1565 } 1566 1567 template<typename _Fn> requires is_constructible_v<_Er, const _Er&> 1568 constexpr auto 1569 and_then(_Fn&& __f) const & 1570 { 1571 using _Up = __expected::__result0<_Fn>; 1572 static_assert(__expected::__is_expected<_Up>); 1573 static_assert(is_same_v<typename _Up::error_type, _Er>); 1574 1575 if (has_value()) 1576 return std::__invoke(std::forward<_Fn>(__f)); 1577 else 1578 return _Up(unexpect, _M_unex); 1579 } 1580 1581 template<typename _Fn> requires is_constructible_v<_Er, _Er> 1582 constexpr auto 1583 and_then(_Fn&& __f) && 1584 { 1585 using _Up = __expected::__result0<_Fn>; 1586 static_assert(__expected::__is_expected<_Up>); 1587 static_assert(is_same_v<typename _Up::error_type, _Er>); 1588 1589 if (has_value()) 1590 return std::__invoke(std::forward<_Fn>(__f)); 1591 else 1592 return _Up(unexpect, std::move(_M_unex)); 1593 } 1594 1595 template<typename _Fn> requires is_constructible_v<_Er, const _Er> 1596 constexpr auto 1597 and_then(_Fn&& __f) const && 1598 { 1599 using _Up = __expected::__result0<_Fn>; 1600 static_assert(__expected::__is_expected<_Up>); 1601 static_assert(is_same_v<typename _Up::error_type, _Er>); 1602 1603 if (has_value()) 1604 return std::__invoke(std::forward<_Fn>(__f)); 1605 else 1606 return _Up(unexpect, std::move(_M_unex)); 1607 } 1608 1609 template<typename _Fn> 1610 constexpr auto 1611 or_else(_Fn&& __f) & 1612 { 1613 using _Gr = __expected::__result<_Fn, _Er&>; 1614 static_assert(__expected::__is_expected<_Gr>); 1615 static_assert(is_same_v<typename _Gr::value_type, _Tp>); 1616 1617 if (has_value()) 1618 return _Gr(); 1619 else 1620 return std::__invoke(std::forward<_Fn>(__f), _M_unex); 1621 } 1622 1623 template<typename _Fn> 1624 constexpr auto 1625 or_else(_Fn&& __f) const & 1626 { 1627 using _Gr = __expected::__result<_Fn, const _Er&>; 1628 static_assert(__expected::__is_expected<_Gr>); 1629 static_assert(is_same_v<typename _Gr::value_type, _Tp>); 1630 1631 if (has_value()) 1632 return _Gr(); 1633 else 1634 return std::__invoke(std::forward<_Fn>(__f), _M_unex); 1635 } 1636 1637 template<typename _Fn> 1638 constexpr auto 1639 or_else(_Fn&& __f) && 1640 { 1641 using _Gr = __expected::__result<_Fn, _Er&&>; 1642 static_assert(__expected::__is_expected<_Gr>); 1643 static_assert(is_same_v<typename _Gr::value_type, _Tp>); 1644 1645 if (has_value()) 1646 return _Gr(); 1647 else 1648 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_unex)); 1649 } 1650 1651 template<typename _Fn> 1652 constexpr auto 1653 or_else(_Fn&& __f) const && 1654 { 1655 using _Gr = __expected::__result<_Fn, const _Er&&>; 1656 static_assert(__expected::__is_expected<_Gr>); 1657 static_assert(is_same_v<typename _Gr::value_type, _Tp>); 1658 1659 if (has_value()) 1660 return _Gr(); 1661 else 1662 return std::__invoke(std::forward<_Fn>(__f), std::move(_M_unex)); 1663 } 1664 1665 template<typename _Fn> requires is_constructible_v<_Er, _Er&> 1666 constexpr auto 1667 transform(_Fn&& __f) & 1668 { 1669 using _Up = __expected::__result0_xform<_Fn>; 1670 using _Res = expected<_Up, _Er>; 1671 1672 if (has_value()) 1673 return _Res(__in_place_inv{}, std::forward<_Fn>(__f)); 1674 else 1675 return _Res(unexpect, _M_unex); 1676 } 1677 1678 template<typename _Fn> requires is_constructible_v<_Er, const _Er&> 1679 constexpr auto 1680 transform(_Fn&& __f) const & 1681 { 1682 using _Up = __expected::__result0_xform<_Fn>; 1683 using _Res = expected<_Up, _Er>; 1684 1685 if (has_value()) 1686 return _Res(__in_place_inv{}, std::forward<_Fn>(__f)); 1687 else 1688 return _Res(unexpect, _M_unex); 1689 } 1690 1691 template<typename _Fn> requires is_constructible_v<_Er, _Er> 1692 constexpr auto 1693 transform(_Fn&& __f) && 1694 { 1695 using _Up = __expected::__result0_xform<_Fn>; 1696 using _Res = expected<_Up, _Er>; 1697 1698 if (has_value()) 1699 return _Res(__in_place_inv{}, std::forward<_Fn>(__f)); 1700 else 1701 return _Res(unexpect, std::move(_M_unex)); 1702 } 1703 1704 template<typename _Fn> requires is_constructible_v<_Er, const _Er> 1705 constexpr auto 1706 transform(_Fn&& __f) const && 1707 { 1708 using _Up = __expected::__result0_xform<_Fn>; 1709 using _Res = expected<_Up, _Er>; 1710 1711 if (has_value()) 1712 return _Res(__in_place_inv{}, std::forward<_Fn>(__f)); 1713 else 1714 return _Res(unexpect, std::move(_M_unex)); 1715 } 1716 1717 template<typename _Fn> 1718 constexpr auto 1719 transform_error(_Fn&& __f) & 1720 { 1721 using _Gr = __expected::__result_xform<_Fn, _Er&>; 1722 using _Res = expected<_Tp, _Gr>; 1723 1724 if (has_value()) 1725 return _Res(); 1726 else 1727 return _Res(__unexpect_inv{}, [&]() { 1728 return std::__invoke(std::forward<_Fn>(__f), 1729 _M_unex); 1730 }); 1731 } 1732 1733 template<typename _Fn> 1734 constexpr auto 1735 transform_error(_Fn&& __f) const & 1736 { 1737 using _Gr = __expected::__result_xform<_Fn, const _Er&>; 1738 using _Res = expected<_Tp, _Gr>; 1739 1740 if (has_value()) 1741 return _Res(); 1742 else 1743 return _Res(__unexpect_inv{}, [&]() { 1744 return std::__invoke(std::forward<_Fn>(__f), 1745 _M_unex); 1746 }); 1747 } 1748 1749 template<typename _Fn> 1750 constexpr auto 1751 transform_error(_Fn&& __f) && 1752 { 1753 using _Gr = __expected::__result_xform<_Fn, _Er&&>; 1754 using _Res = expected<_Tp, _Gr>; 1755 1756 if (has_value()) 1757 return _Res(); 1758 else 1759 return _Res(__unexpect_inv{}, [&]() { 1760 return std::__invoke(std::forward<_Fn>(__f), 1761 std::move(_M_unex)); 1762 }); 1763 } 1764 1765 template<typename _Fn> 1766 constexpr auto 1767 transform_error(_Fn&& __f) const && 1768 { 1769 using _Gr = __expected::__result_xform<_Fn, const _Er&&>; 1770 using _Res = expected<_Tp, _Gr>; 1771 1772 if (has_value()) 1773 return _Res(); 1774 else 1775 return _Res(__unexpect_inv{}, [&]() { 1776 return std::__invoke(std::forward<_Fn>(__f), 1777 std::move(_M_unex)); 1778 }); 1779 } 1780 1781 // equality operators 1782 1783 template<typename _Up, typename _Er2> 1784 requires is_void_v<_Up> 1785 friend constexpr bool 1786 operator==(const expected& __x, const expected<_Up, _Er2>& __y) 1787 // FIXME: noexcept(noexcept(bool(__x.error() == __y.error()))) 1788 { 1789 if (__x.has_value()) 1790 return __y.has_value(); 1791 else 1792 return !__y.has_value() && bool(__x.error() == __y.error()); 1793 } 1794 1795 template<typename _Er2> 1796 friend constexpr bool 1797 operator==(const expected& __x, const unexpected<_Er2>& __e) 1798 // FIXME: noexcept(noexcept(bool(__x.error() == __e.error()))) 1799 { return !__x.has_value() && bool(__x.error() == __e.error()); } 1800 1801 friend constexpr void 1802 swap(expected& __x, expected& __y) 1803 noexcept(noexcept(__x.swap(__y))) 1804 requires requires { __x.swap(__y); } 1805 { __x.swap(__y); } 1806 1807 private: 1808 template<typename, typename> friend class expected; 1809 1810 template<typename _Vp> 1811 constexpr void 1812 _M_assign_unex(_Vp&& __v) 1813 { 1814 if (_M_has_value) 1815 { 1816 std::construct_at(__builtin_addressof(_M_unex), 1817 std::forward<_Vp>(__v)); 1818 _M_has_value = false; 1819 } 1820 else 1821 _M_unex = std::forward<_Vp>(__v); 1822 } 1823 1824 using __in_place_inv = __expected::__in_place_inv; 1825 using __unexpect_inv = __expected::__unexpect_inv; 1826 1827 template<typename _Fn> 1828 explicit constexpr 1829 expected(__in_place_inv, _Fn&& __fn) 1830 : _M_void(), _M_has_value(true) 1831 { std::forward<_Fn>(__fn)(); } 1832 1833 template<typename _Fn> 1834 explicit constexpr 1835 expected(__unexpect_inv, _Fn&& __fn) 1836 : _M_unex(std::forward<_Fn>(__fn)()), _M_has_value(false) 1837 { } 1838 1839 union { 1840 struct { } _M_void; 1841 _Er _M_unex; 1842 }; 1843 1844 bool _M_has_value; 1845 }; 1846 /// @} 1847 1848 _GLIBCXX_END_NAMESPACE_VERSION 1849 } // namespace std 1850 1851 #endif // __cpp_lib_expected 1852 #endif // _GLIBCXX_EXPECTED 1853
Indexes created Mon Mar 02 05:31:46 UTC 2026