1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 #ifndef _LIBCPP___EXPECTED_EXPECTED_H 10 #define _LIBCPP___EXPECTED_EXPECTED_H 11 12 #include <__assert> 13 #include <__config> 14 #include <__expected/bad_expected_access.h> 15 #include <__expected/unexpect.h> 16 #include <__expected/unexpected.h> 17 #include <__functional/invoke.h> 18 #include <__memory/addressof.h> 19 #include <__memory/construct_at.h> 20 #include <__type_traits/conjunction.h> 21 #include <__type_traits/disjunction.h> 22 #include <__type_traits/integral_constant.h> 23 #include <__type_traits/is_assignable.h> 24 #include <__type_traits/is_constructible.h> 25 #include <__type_traits/is_convertible.h> 26 #include <__type_traits/is_copy_assignable.h> 27 #include <__type_traits/is_copy_constructible.h> 28 #include <__type_traits/is_default_constructible.h> 29 #include <__type_traits/is_function.h> 30 #include <__type_traits/is_move_assignable.h> 31 #include <__type_traits/is_move_constructible.h> 32 #include <__type_traits/is_nothrow_constructible.h> 33 #include <__type_traits/is_nothrow_copy_assignable.h> 34 #include <__type_traits/is_nothrow_copy_constructible.h> 35 #include <__type_traits/is_nothrow_default_constructible.h> 36 #include <__type_traits/is_nothrow_move_assignable.h> 37 #include <__type_traits/is_nothrow_move_constructible.h> 38 #include <__type_traits/is_reference.h> 39 #include <__type_traits/is_same.h> 40 #include <__type_traits/is_swappable.h> 41 #include <__type_traits/is_trivially_copy_constructible.h> 42 #include <__type_traits/is_trivially_destructible.h> 43 #include <__type_traits/is_trivially_move_constructible.h> 44 #include <__type_traits/is_void.h> 45 #include <__type_traits/lazy.h> 46 #include <__type_traits/negation.h> 47 #include <__type_traits/remove_cv.h> 48 #include <__type_traits/remove_cvref.h> 49 #include <__utility/as_const.h> 50 #include <__utility/exception_guard.h> 51 #include <__utility/forward.h> 52 #include <__utility/in_place.h> 53 #include <__utility/move.h> 54 #include <__utility/swap.h> 55 #include <__verbose_abort> 56 #include <initializer_list> 57 58 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 59 # pragma GCC system_header 60 #endif 61 62 _LIBCPP_PUSH_MACROS 63 #include <__undef_macros> 64 65 #if _LIBCPP_STD_VER >= 23 66 67 _LIBCPP_BEGIN_NAMESPACE_STD 68 69 template <class _Tp, class _Err> 70 class expected; 71 72 template <class _Tp> 73 struct __is_std_expected : false_type {}; 74 75 template <class _Tp, class _Err> 76 struct __is_std_expected<expected<_Tp, _Err>> : true_type {}; 77 78 struct __expected_construct_in_place_from_invoke_tag {}; 79 struct __expected_construct_unexpected_from_invoke_tag {}; 80 81 template <class _Err, class _Arg> 82 _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) { 83 # ifndef _LIBCPP_HAS_NO_EXCEPTIONS 84 throw bad_expected_access<_Err>(std::forward<_Arg>(__arg)); 85 # else 86 (void)__arg; 87 _LIBCPP_VERBOSE_ABORT("bad_expected_access was thrown in -fno-exceptions mode"); 88 # endif 89 } 90 91 template <class _Tp, class _Err> 92 class expected { 93 static_assert( 94 !is_reference_v<_Tp> && 95 !is_function_v<_Tp> && 96 !is_same_v<remove_cv_t<_Tp>, in_place_t> && 97 !is_same_v<remove_cv_t<_Tp>, unexpect_t> && 98 !__is_std_unexpected<remove_cv_t<_Tp>>::value && 99 __valid_std_unexpected<_Err>::value 100 , 101 "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a " 102 "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a " 103 "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the " 104 "definition of the template expected<T, E> with a type for the E parameter that is not a valid " 105 "template argument for unexpected is ill-formed."); 106 107 template <class _Up, class _OtherErr> 108 friend class expected; 109 110 public: 111 using value_type = _Tp; 112 using error_type = _Err; 113 using unexpected_type = unexpected<_Err>; 114 115 template <class _Up> 116 using rebind = expected<_Up, error_type>; 117 118 // [expected.object.ctor], constructors 119 _LIBCPP_HIDE_FROM_ABI constexpr expected() 120 noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened 121 requires is_default_constructible_v<_Tp> 122 : __union_(std::in_place), __has_val_(true) {} 123 124 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete; 125 126 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) 127 requires(is_copy_constructible_v<_Tp> && 128 is_copy_constructible_v<_Err> && 129 is_trivially_copy_constructible_v<_Tp> && 130 is_trivially_copy_constructible_v<_Err>) 131 = default; 132 133 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other) 134 noexcept(is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened 135 requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && 136 !(is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>)) 137 : __union_(__other.__has_val_, __other.__union_), __has_val_(__other.__has_val_) { } 138 139 _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&) 140 requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> 141 && is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>) 142 = default; 143 144 _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other) 145 noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>) 146 requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && 147 !(is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)) 148 : __union_(__other.__has_val_, std::move(__other.__union_)), __has_val_(__other.__has_val_) { } 149 150 private: 151 template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual> 152 using __can_convert = 153 _And< is_constructible<_Tp, _UfQual>, 154 is_constructible<_Err, _OtherErrQual>, 155 _If<_Not<is_same<remove_cv_t<_Tp>, bool>>::value, 156 _And< _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>, 157 _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>, 158 _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>, 159 _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>, 160 _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>, 161 _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>, 162 _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>, 163 _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>>, 164 true_type>, 165 _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>, 166 _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>, 167 _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>, 168 _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >; 169 170 template <class _Func, class... _Args> 171 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( 172 std::__expected_construct_in_place_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) 173 : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(true) {} 174 175 template <class _Func, class... _Args> 176 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( 177 std::__expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) 178 : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {} 179 180 public: 181 template <class _Up, class _OtherErr> 182 requires __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value 183 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Up&, _Tp> || 184 !is_convertible_v<const _OtherErr&, _Err>) 185 expected(const expected<_Up, _OtherErr>& __other) 186 noexcept(is_nothrow_constructible_v<_Tp, const _Up&> && 187 is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened 188 : __union_(__other.__has_val_, __other.__union_), __has_val_(__other.__has_val_) {} 189 190 template <class _Up, class _OtherErr> 191 requires __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value 192 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp> || !is_convertible_v<_OtherErr, _Err>) 193 expected(expected<_Up, _OtherErr>&& __other) 194 noexcept(is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened 195 : __union_(__other.__has_val_, std::move(__other.__union_)), __has_val_(__other.__has_val_) {} 196 197 template <class _Up = _Tp> 198 requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> && 199 is_constructible_v<_Tp, _Up> && !__is_std_unexpected<remove_cvref_t<_Up>>::value && 200 (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_expected<remove_cvref_t<_Up>>::value)) 201 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>) 202 expected(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened 203 : __union_(std::in_place, std::forward<_Up>(__u)), __has_val_(true) {} 204 205 template <class _OtherErr> 206 requires is_constructible_v<_Err, const _OtherErr&> 207 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) 208 expected(const unexpected<_OtherErr>& __unex) 209 noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened 210 : __union_(std::unexpect, __unex.error()), __has_val_(false) {} 211 212 template <class _OtherErr> 213 requires is_constructible_v<_Err, _OtherErr> 214 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) 215 expected(unexpected<_OtherErr>&& __unex) 216 noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened 217 : __union_(std::unexpect, std::move(__unex.error())), __has_val_(false) {} 218 219 template <class... _Args> 220 requires is_constructible_v<_Tp, _Args...> 221 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args) 222 noexcept(is_nothrow_constructible_v<_Tp, _Args...>) // strengthened 223 : __union_(std::in_place, std::forward<_Args>(__args)...), __has_val_(true) {} 224 225 template <class _Up, class... _Args> 226 requires is_constructible_v< _Tp, initializer_list<_Up>&, _Args... > 227 _LIBCPP_HIDE_FROM_ABI constexpr explicit 228 expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) 229 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened 230 : __union_(std::in_place, __il, std::forward<_Args>(__args)...), __has_val_(true) {} 231 232 template <class... _Args> 233 requires is_constructible_v<_Err, _Args...> 234 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) 235 noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened 236 : __union_(std::unexpect, std::forward<_Args>(__args)...), __has_val_(false) {} 237 238 template <class _Up, class... _Args> 239 requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... > 240 _LIBCPP_HIDE_FROM_ABI constexpr explicit 241 expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) 242 noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened 243 : __union_(std::unexpect, __il, std::forward<_Args>(__args)...), __has_val_(false) {} 244 245 // [expected.object.dtor], destructor 246 247 _LIBCPP_HIDE_FROM_ABI constexpr ~expected() 248 requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>) 249 = default; 250 251 _LIBCPP_HIDE_FROM_ABI constexpr ~expected() 252 requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>) 253 { 254 if (__has_val_) { 255 std::destroy_at(std::addressof(__union_.__val_)); 256 } else { 257 std::destroy_at(std::addressof(__union_.__unex_)); 258 } 259 } 260 261 private: 262 template <class _T1, class _T2, class... _Args> 263 _LIBCPP_HIDE_FROM_ABI static constexpr void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) { 264 if constexpr (is_nothrow_constructible_v<_T1, _Args...>) { 265 std::destroy_at(std::addressof(__oldval)); 266 std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...); 267 } else if constexpr (is_nothrow_move_constructible_v<_T1>) { 268 _T1 __tmp(std::forward<_Args>(__args)...); 269 std::destroy_at(std::addressof(__oldval)); 270 std::construct_at(std::addressof(__newval), std::move(__tmp)); 271 } else { 272 static_assert( 273 is_nothrow_move_constructible_v<_T2>, 274 "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can " 275 "be reverted to the previous state in case an exception is thrown during the assignment."); 276 _T2 __tmp(std::move(__oldval)); 277 std::destroy_at(std::addressof(__oldval)); 278 auto __trans = 279 std::__make_exception_guard([&] { std::construct_at(std::addressof(__oldval), std::move(__tmp)); }); 280 std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...); 281 __trans.__complete(); 282 } 283 } 284 285 public: 286 // [expected.object.assign], assignment 287 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete; 288 289 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) 290 noexcept(is_nothrow_copy_assignable_v<_Tp> && 291 is_nothrow_copy_constructible_v<_Tp> && 292 is_nothrow_copy_assignable_v<_Err> && 293 is_nothrow_copy_constructible_v<_Err>) // strengthened 294 requires(is_copy_assignable_v<_Tp> && 295 is_copy_constructible_v<_Tp> && 296 is_copy_assignable_v<_Err> && 297 is_copy_constructible_v<_Err> && 298 (is_nothrow_move_constructible_v<_Tp> || 299 is_nothrow_move_constructible_v<_Err>)) 300 { 301 if (__has_val_ && __rhs.__has_val_) { 302 __union_.__val_ = __rhs.__union_.__val_; 303 } else if (__has_val_) { 304 __reinit_expected(__union_.__unex_, __union_.__val_, __rhs.__union_.__unex_); 305 } else if (__rhs.__has_val_) { 306 __reinit_expected(__union_.__val_, __union_.__unex_, __rhs.__union_.__val_); 307 } else { 308 __union_.__unex_ = __rhs.__union_.__unex_; 309 } 310 // note: only reached if no exception+rollback was done inside __reinit_expected 311 __has_val_ = __rhs.__has_val_; 312 return *this; 313 } 314 315 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs) 316 noexcept(is_nothrow_move_assignable_v<_Tp> && 317 is_nothrow_move_constructible_v<_Tp> && 318 is_nothrow_move_assignable_v<_Err> && 319 is_nothrow_move_constructible_v<_Err>) 320 requires(is_move_constructible_v<_Tp> && 321 is_move_assignable_v<_Tp> && 322 is_move_constructible_v<_Err> && 323 is_move_assignable_v<_Err> && 324 (is_nothrow_move_constructible_v<_Tp> || 325 is_nothrow_move_constructible_v<_Err>)) 326 { 327 if (__has_val_ && __rhs.__has_val_) { 328 __union_.__val_ = std::move(__rhs.__union_.__val_); 329 } else if (__has_val_) { 330 __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__rhs.__union_.__unex_)); 331 } else if (__rhs.__has_val_) { 332 __reinit_expected(__union_.__val_, __union_.__unex_, std::move(__rhs.__union_.__val_)); 333 } else { 334 __union_.__unex_ = std::move(__rhs.__union_.__unex_); 335 } 336 // note: only reached if no exception+rollback was done inside __reinit_expected 337 __has_val_ = __rhs.__has_val_; 338 return *this; 339 } 340 341 template <class _Up = _Tp> 342 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v) 343 requires(!is_same_v<expected, remove_cvref_t<_Up>> && 344 !__is_std_unexpected<remove_cvref_t<_Up>>::value && 345 is_constructible_v<_Tp, _Up> && 346 is_assignable_v<_Tp&, _Up> && 347 (is_nothrow_constructible_v<_Tp, _Up> || 348 is_nothrow_move_constructible_v<_Tp> || 349 is_nothrow_move_constructible_v<_Err>)) 350 { 351 if (__has_val_) { 352 __union_.__val_ = std::forward<_Up>(__v); 353 } else { 354 __reinit_expected(__union_.__val_, __union_.__unex_, std::forward<_Up>(__v)); 355 __has_val_ = true; 356 } 357 return *this; 358 } 359 360 private: 361 template <class _OtherErrQual> 362 static constexpr bool __can_assign_from_unexpected = 363 _And< is_constructible<_Err, _OtherErrQual>, 364 is_assignable<_Err&, _OtherErrQual>, 365 _Lazy<_Or, 366 is_nothrow_constructible<_Err, _OtherErrQual>, 367 is_nothrow_move_constructible<_Tp>, 368 is_nothrow_move_constructible<_Err>> >::value; 369 370 public: 371 template <class _OtherErr> 372 requires(__can_assign_from_unexpected<const _OtherErr&>) 373 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) { 374 if (__has_val_) { 375 __reinit_expected(__union_.__unex_, __union_.__val_, __un.error()); 376 __has_val_ = false; 377 } else { 378 __union_.__unex_ = __un.error(); 379 } 380 return *this; 381 } 382 383 template <class _OtherErr> 384 requires(__can_assign_from_unexpected<_OtherErr>) 385 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) { 386 if (__has_val_) { 387 __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__un.error())); 388 __has_val_ = false; 389 } else { 390 __union_.__unex_ = std::move(__un.error()); 391 } 392 return *this; 393 } 394 395 template <class... _Args> 396 requires is_nothrow_constructible_v<_Tp, _Args...> 397 _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(_Args&&... __args) noexcept { 398 if (__has_val_) { 399 std::destroy_at(std::addressof(__union_.__val_)); 400 } else { 401 std::destroy_at(std::addressof(__union_.__unex_)); 402 } 403 std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...); 404 __has_val_ = true; 405 return __union_.__val_; 406 } 407 408 template <class _Up, class... _Args> 409 requires is_nothrow_constructible_v< _Tp, initializer_list<_Up>&, _Args... > 410 _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept { 411 if (__has_val_) { 412 std::destroy_at(std::addressof(__union_.__val_)); 413 } else { 414 std::destroy_at(std::addressof(__union_.__unex_)); 415 } 416 std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...); 417 __has_val_ = true; 418 return __union_.__val_; 419 } 420 421 422 public: 423 // [expected.object.swap], swap 424 _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs) 425 noexcept(is_nothrow_move_constructible_v<_Tp> && 426 is_nothrow_swappable_v<_Tp> && 427 is_nothrow_move_constructible_v<_Err> && 428 is_nothrow_swappable_v<_Err>) 429 requires(is_swappable_v<_Tp> && 430 is_swappable_v<_Err> && 431 is_move_constructible_v<_Tp> && 432 is_move_constructible_v<_Err> && 433 (is_nothrow_move_constructible_v<_Tp> || 434 is_nothrow_move_constructible_v<_Err>)) 435 { 436 auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) { 437 if constexpr (is_nothrow_move_constructible_v<_Err>) { 438 _Err __tmp(std::move(__with_err.__union_.__unex_)); 439 std::destroy_at(std::addressof(__with_err.__union_.__unex_)); 440 auto __trans = std::__make_exception_guard([&] { 441 std::construct_at(std::addressof(__with_err.__union_.__unex_), std::move(__tmp)); 442 }); 443 std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__with_val.__union_.__val_)); 444 __trans.__complete(); 445 std::destroy_at(std::addressof(__with_val.__union_.__val_)); 446 std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__tmp)); 447 } else { 448 static_assert(is_nothrow_move_constructible_v<_Tp>, 449 "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so " 450 "that it can be reverted to the previous state in case an exception is thrown during swap."); 451 _Tp __tmp(std::move(__with_val.__union_.__val_)); 452 std::destroy_at(std::addressof(__with_val.__union_.__val_)); 453 auto __trans = std::__make_exception_guard([&] { 454 std::construct_at(std::addressof(__with_val.__union_.__val_), std::move(__tmp)); 455 }); 456 std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_)); 457 __trans.__complete(); 458 std::destroy_at(std::addressof(__with_err.__union_.__unex_)); 459 std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__tmp)); 460 } 461 __with_val.__has_val_ = false; 462 __with_err.__has_val_ = true; 463 }; 464 465 if (__has_val_) { 466 if (__rhs.__has_val_) { 467 using std::swap; 468 swap(__union_.__val_, __rhs.__union_.__val_); 469 } else { 470 __swap_val_unex_impl(*this, __rhs); 471 } 472 } else { 473 if (__rhs.__has_val_) { 474 __swap_val_unex_impl(__rhs, *this); 475 } else { 476 using std::swap; 477 swap(__union_.__unex_, __rhs.__union_.__unex_); 478 } 479 } 480 } 481 482 _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) 483 noexcept(noexcept(__x.swap(__y))) 484 requires requires { __x.swap(__y); } 485 { 486 __x.swap(__y); 487 } 488 489 // [expected.object.obs], observers 490 _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { 491 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator-> requires the expected to contain a value"); 492 return std::addressof(__union_.__val_); 493 } 494 495 _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { 496 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator-> requires the expected to contain a value"); 497 return std::addressof(__union_.__val_); 498 } 499 500 _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept { 501 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator* requires the expected to contain a value"); 502 return __union_.__val_; 503 } 504 505 _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept { 506 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator* requires the expected to contain a value"); 507 return __union_.__val_; 508 } 509 510 _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept { 511 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator* requires the expected to contain a value"); 512 return std::move(__union_.__val_); 513 } 514 515 _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept { 516 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator* requires the expected to contain a value"); 517 return std::move(__union_.__val_); 518 } 519 520 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; } 521 522 _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; } 523 524 _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& value() const& { 525 static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); 526 if (!__has_val_) { 527 std::__throw_bad_expected_access<_Err>(std::as_const(error())); 528 } 529 return __union_.__val_; 530 } 531 532 _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & { 533 static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); 534 if (!__has_val_) { 535 std::__throw_bad_expected_access<_Err>(std::as_const(error())); 536 } 537 return __union_.__val_; 538 } 539 540 _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& { 541 static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>, 542 "error_type has to be both copy constructible and constructible from decltype(std::move(error()))"); 543 if (!__has_val_) { 544 std::__throw_bad_expected_access<_Err>(std::move(error())); 545 } 546 return std::move(__union_.__val_); 547 } 548 549 _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && { 550 static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>, 551 "error_type has to be both copy constructible and constructible from decltype(std::move(error()))"); 552 if (!__has_val_) { 553 std::__throw_bad_expected_access<_Err>(std::move(error())); 554 } 555 return std::move(__union_.__val_); 556 } 557 558 _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { 559 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 560 return __union_.__unex_; 561 } 562 563 _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { 564 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 565 return __union_.__unex_; 566 } 567 568 _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { 569 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 570 return std::move(__union_.__unex_); 571 } 572 573 _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { 574 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 575 return std::move(__union_.__unex_); 576 } 577 578 template <class _Up> 579 _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& { 580 static_assert(is_copy_constructible_v<_Tp>, "value_type has to be copy constructible"); 581 static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type"); 582 return __has_val_ ? __union_.__val_ : static_cast<_Tp>(std::forward<_Up>(__v)); 583 } 584 585 template <class _Up> 586 _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && { 587 static_assert(is_move_constructible_v<_Tp>, "value_type has to be move constructible"); 588 static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type"); 589 return __has_val_ ? std::move(__union_.__val_) : static_cast<_Tp>(std::forward<_Up>(__v)); 590 } 591 592 template <class _Up = _Err> 593 _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) const& { 594 static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); 595 static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); 596 if (has_value()) 597 return std::forward<_Up>(__error); 598 return error(); 599 } 600 601 template <class _Up = _Err> 602 _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) && { 603 static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible"); 604 static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); 605 if (has_value()) 606 return std::forward<_Up>(__error); 607 return std::move(error()); 608 } 609 610 // [expected.void.monadic], monadic 611 template <class _Func> 612 requires is_constructible_v<_Err, _Err&> 613 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & { 614 using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>; 615 static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected"); 616 static_assert(is_same_v<typename _Up::error_type, _Err>, 617 "The result of f(**this) must have the same error_type as this expected"); 618 if (has_value()) { 619 return std::invoke(std::forward<_Func>(__f), __union_.__val_); 620 } 621 return _Up(unexpect, error()); 622 } 623 624 template <class _Func> 625 requires is_constructible_v<_Err, const _Err&> 626 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& { 627 using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>; 628 static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected"); 629 static_assert(is_same_v<typename _Up::error_type, _Err>, 630 "The result of f(**this) must have the same error_type as this expected"); 631 if (has_value()) { 632 return std::invoke(std::forward<_Func>(__f), __union_.__val_); 633 } 634 return _Up(unexpect, error()); 635 } 636 637 template <class _Func> 638 requires is_constructible_v<_Err, _Err&&> 639 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && { 640 using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>; 641 static_assert( 642 __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected"); 643 static_assert(is_same_v<typename _Up::error_type, _Err>, 644 "The result of f(std::move(**this)) must have the same error_type as this expected"); 645 if (has_value()) { 646 return std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_)); 647 } 648 return _Up(unexpect, std::move(error())); 649 } 650 651 template <class _Func> 652 requires is_constructible_v<_Err, const _Err&&> 653 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& { 654 using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>; 655 static_assert( 656 __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected"); 657 static_assert(is_same_v<typename _Up::error_type, _Err>, 658 "The result of f(std::move(**this)) must have the same error_type as this expected"); 659 if (has_value()) { 660 return std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_)); 661 } 662 return _Up(unexpect, std::move(error())); 663 } 664 665 template <class _Func> 666 requires is_constructible_v<_Tp, _Tp&> 667 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & { 668 using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&>>; 669 static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); 670 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 671 "The result of f(error()) must have the same value_type as this expected"); 672 if (has_value()) { 673 return _Gp(in_place, __union_.__val_); 674 } 675 return std::invoke(std::forward<_Func>(__f), error()); 676 } 677 678 template <class _Func> 679 requires is_constructible_v<_Tp, const _Tp&> 680 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& { 681 using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&>>; 682 static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); 683 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 684 "The result of f(error()) must have the same value_type as this expected"); 685 if (has_value()) { 686 return _Gp(in_place, __union_.__val_); 687 } 688 return std::invoke(std::forward<_Func>(__f), error()); 689 } 690 691 template <class _Func> 692 requires is_constructible_v<_Tp, _Tp&&> 693 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && { 694 using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>; 695 static_assert( 696 __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); 697 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 698 "The result of f(std::move(error())) must have the same value_type as this expected"); 699 if (has_value()) { 700 return _Gp(in_place, std::move(__union_.__val_)); 701 } 702 return std::invoke(std::forward<_Func>(__f), std::move(error())); 703 } 704 705 template <class _Func> 706 requires is_constructible_v<_Tp, const _Tp&&> 707 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& { 708 using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>; 709 static_assert( 710 __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected"); 711 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 712 "The result of f(std::move(error())) must have the same value_type as this expected"); 713 if (has_value()) { 714 return _Gp(in_place, std::move(__union_.__val_)); 715 } 716 return std::invoke(std::forward<_Func>(__f), std::move(error())); 717 } 718 719 template <class _Func> 720 requires is_constructible_v<_Err, _Err&> 721 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & { 722 using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>; 723 if (!has_value()) { 724 return expected<_Up, _Err>(unexpect, error()); 725 } 726 if constexpr (!is_void_v<_Up>) { 727 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), __union_.__val_); 728 } else { 729 std::invoke(std::forward<_Func>(__f), __union_.__val_); 730 return expected<_Up, _Err>(); 731 } 732 } 733 734 template <class _Func> 735 requires is_constructible_v<_Err, const _Err&> 736 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& { 737 using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>; 738 if (!has_value()) { 739 return expected<_Up, _Err>(unexpect, error()); 740 } 741 if constexpr (!is_void_v<_Up>) { 742 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), __union_.__val_); 743 } else { 744 std::invoke(std::forward<_Func>(__f), __union_.__val_); 745 return expected<_Up, _Err>(); 746 } 747 } 748 749 template <class _Func> 750 requires is_constructible_v<_Err, _Err&&> 751 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && { 752 using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>; 753 if (!has_value()) { 754 return expected<_Up, _Err>(unexpect, std::move(error())); 755 } 756 if constexpr (!is_void_v<_Up>) { 757 return expected<_Up, _Err>( 758 __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(__union_.__val_)); 759 } else { 760 std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_)); 761 return expected<_Up, _Err>(); 762 } 763 } 764 765 template <class _Func> 766 requires is_constructible_v<_Err, const _Err&&> 767 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& { 768 using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>; 769 if (!has_value()) { 770 return expected<_Up, _Err>(unexpect, std::move(error())); 771 } 772 if constexpr (!is_void_v<_Up>) { 773 return expected<_Up, _Err>( 774 __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(__union_.__val_)); 775 } else { 776 std::invoke(std::forward<_Func>(__f), std::move(__union_.__val_)); 777 return expected<_Up, _Err>(); 778 } 779 } 780 781 template <class _Func> 782 requires is_constructible_v<_Tp, _Tp&> 783 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & { 784 using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&>>; 785 static_assert(__valid_std_unexpected<_Gp>::value, 786 "The result of f(error()) must be a valid template argument for unexpected"); 787 if (has_value()) { 788 return expected<_Tp, _Gp>(in_place, __union_.__val_); 789 } 790 return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); 791 } 792 793 template <class _Func> 794 requires is_constructible_v<_Tp, const _Tp&> 795 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& { 796 using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&>>; 797 static_assert(__valid_std_unexpected<_Gp>::value, 798 "The result of f(error()) must be a valid template argument for unexpected"); 799 if (has_value()) { 800 return expected<_Tp, _Gp>(in_place, __union_.__val_); 801 } 802 return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); 803 } 804 805 template <class _Func> 806 requires is_constructible_v<_Tp, _Tp&&> 807 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && { 808 using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&&>>; 809 static_assert(__valid_std_unexpected<_Gp>::value, 810 "The result of f(std::move(error())) must be a valid template argument for unexpected"); 811 if (has_value()) { 812 return expected<_Tp, _Gp>(in_place, std::move(__union_.__val_)); 813 } 814 return expected<_Tp, _Gp>( 815 __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); 816 } 817 818 template <class _Func> 819 requires is_constructible_v<_Tp, const _Tp&&> 820 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& { 821 using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&&>>; 822 static_assert(__valid_std_unexpected<_Gp>::value, 823 "The result of f(std::move(error())) must be a valid template argument for unexpected"); 824 if (has_value()) { 825 return expected<_Tp, _Gp>(in_place, std::move(__union_.__val_)); 826 } 827 return expected<_Tp, _Gp>( 828 __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); 829 } 830 831 // [expected.object.eq], equality operators 832 template <class _T2, class _E2> 833 requires(!is_void_v<_T2>) 834 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) { 835 if (__x.__has_val_ != __y.__has_val_) { 836 return false; 837 } else { 838 if (__x.__has_val_) { 839 return __x.__union_.__val_ == __y.__union_.__val_; 840 } else { 841 return __x.__union_.__unex_ == __y.__union_.__unex_; 842 } 843 } 844 } 845 846 template <class _T2> 847 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const _T2& __v) { 848 return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v); 849 } 850 851 template <class _E2> 852 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __e) { 853 return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error()); 854 } 855 856 private: 857 template <class _ValueType, class _ErrorType> 858 union __union_t { 859 template <class... _Args> 860 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::in_place_t, _Args&&... __args) 861 : __val_(std::forward<_Args>(__args)...) {} 862 863 template <class... _Args> 864 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::unexpect_t, _Args&&... __args) 865 : __unex_(std::forward<_Args>(__args)...) {} 866 867 template <class _Func, class... _Args> 868 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 869 std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args) 870 : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 871 872 template <class _Func, class... _Args> 873 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 874 std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) 875 : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 876 877 template <class _Union> 878 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(bool __has_val, _Union&& __other) { 879 if (__has_val) 880 std::construct_at(std::addressof(__val_), std::forward<_Union>(__other).__val_); 881 else 882 std::construct_at(std::addressof(__unex_), std::forward<_Union>(__other).__unex_); 883 } 884 885 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 886 requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>) 887 = default; 888 889 // the expected's destructor handles this 890 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {} 891 892 _ValueType __val_; 893 _ErrorType __unex_; 894 }; 895 896 // use named union because [[no_unique_address]] cannot be applied to an unnamed union, 897 // also guaranteed elision into a potentially-overlapping subobject is unsettled (and 898 // it's not clear that it's implementable, given that the function is allowed to clobber 899 // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107. 900 template <class _ValueType, class _ErrorType> 901 requires(is_trivially_move_constructible_v<_ValueType> && is_trivially_move_constructible_v<_ErrorType>) 902 union __union_t<_ValueType, _ErrorType> { 903 _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = default; 904 _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = default; 905 906 template <class... _Args> 907 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::in_place_t, _Args&&... __args) 908 : __val_(std::forward<_Args>(__args)...) {} 909 910 template <class... _Args> 911 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::unexpect_t, _Args&&... __args) 912 : __unex_(std::forward<_Args>(__args)...) {} 913 914 template <class _Func, class... _Args> 915 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 916 std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args) 917 : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 918 919 template <class _Func, class... _Args> 920 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 921 std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) 922 : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 923 924 template <class _Union> 925 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(bool __has_val, _Union&& __other) { 926 if (__has_val) 927 std::construct_at(std::addressof(__val_), std::forward<_Union>(__other).__val_); 928 else 929 std::construct_at(std::addressof(__unex_), std::forward<_Union>(__other).__unex_); 930 } 931 932 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 933 requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>) 934 = default; 935 936 // the expected's destructor handles this 937 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 938 requires(!is_trivially_destructible_v<_ValueType> || !is_trivially_destructible_v<_ErrorType>) 939 {} 940 941 _LIBCPP_NO_UNIQUE_ADDRESS _ValueType __val_; 942 _LIBCPP_NO_UNIQUE_ADDRESS _ErrorType __unex_; 943 }; 944 945 _LIBCPP_NO_UNIQUE_ADDRESS __union_t<_Tp, _Err> __union_; 946 bool __has_val_; 947 }; 948 949 template <class _Tp, class _Err> 950 requires is_void_v<_Tp> 951 class expected<_Tp, _Err> { 952 static_assert(__valid_std_unexpected<_Err>::value, 953 "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a " 954 "valid argument for unexpected<E> is ill-formed"); 955 956 template <class, class> 957 friend class expected; 958 959 template <class _Up, class _OtherErr, class _OtherErrQual> 960 using __can_convert = 961 _And< is_void<_Up>, 962 is_constructible<_Err, _OtherErrQual>, 963 _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>, 964 _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>, 965 _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>, 966 _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>; 967 968 public: 969 using value_type = _Tp; 970 using error_type = _Err; 971 using unexpected_type = unexpected<_Err>; 972 973 template <class _Up> 974 using rebind = expected<_Up, error_type>; 975 976 // [expected.void.ctor], constructors 977 _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __has_val_(true) {} 978 979 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete; 980 981 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) 982 requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>) 983 = default; 984 985 _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs) 986 noexcept(is_nothrow_copy_constructible_v<_Err>) // strengthened 987 requires(is_copy_constructible_v<_Err> && !is_trivially_copy_constructible_v<_Err>) 988 : __union_(__rhs.__has_val_, __rhs.__union_), __has_val_(__rhs.__has_val_) {} 989 990 _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&) 991 requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>) 992 = default; 993 994 _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs) 995 noexcept(is_nothrow_move_constructible_v<_Err>) 996 requires(is_move_constructible_v<_Err> && !is_trivially_move_constructible_v<_Err>) 997 : __union_(__rhs.__has_val_, std::move(__rhs.__union_)), __has_val_(__rhs.__has_val_) {} 998 999 template <class _Up, class _OtherErr> 1000 requires __can_convert<_Up, _OtherErr, const _OtherErr&>::value 1001 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) 1002 expected(const expected<_Up, _OtherErr>& __rhs) 1003 noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened 1004 : __union_(__rhs.__has_val_, __rhs.__union_), __has_val_(__rhs.__has_val_) {} 1005 1006 template <class _Up, class _OtherErr> 1007 requires __can_convert<_Up, _OtherErr, _OtherErr>::value 1008 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) 1009 expected(expected<_Up, _OtherErr>&& __rhs) 1010 noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened 1011 : __union_(__rhs.__has_val_, std::move(__rhs.__union_)), __has_val_(__rhs.__has_val_) {} 1012 1013 template <class _OtherErr> 1014 requires is_constructible_v<_Err, const _OtherErr&> 1015 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) 1016 expected(const unexpected<_OtherErr>& __unex) 1017 noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened 1018 : __union_(std::unexpect, __unex.error()), __has_val_(false) {} 1019 1020 template <class _OtherErr> 1021 requires is_constructible_v<_Err, _OtherErr> 1022 _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>) 1023 expected(unexpected<_OtherErr>&& __unex) 1024 noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened 1025 : __union_(std::unexpect, std::move(__unex.error())), __has_val_(false) {} 1026 1027 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __has_val_(true) {} 1028 1029 template <class... _Args> 1030 requires is_constructible_v<_Err, _Args...> 1031 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) 1032 noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened 1033 : __union_(std::unexpect, std::forward<_Args>(__args)...), __has_val_(false) {} 1034 1035 template <class _Up, class... _Args> 1036 requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... > 1037 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) 1038 noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened 1039 : __union_(std::unexpect, __il, std::forward<_Args>(__args)...), __has_val_(false) {} 1040 1041 private: 1042 template <class _Func> 1043 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(__expected_construct_in_place_from_invoke_tag, _Func&& __f) 1044 : __has_val_(true) { 1045 std::invoke(std::forward<_Func>(__f)); 1046 } 1047 1048 template <class _Func, class... _Args> 1049 _LIBCPP_HIDE_FROM_ABI constexpr explicit expected( 1050 __expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args) 1051 : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {} 1052 1053 public: 1054 // [expected.void.dtor], destructor 1055 1056 _LIBCPP_HIDE_FROM_ABI constexpr ~expected() 1057 requires is_trivially_destructible_v<_Err> 1058 = default; 1059 1060 _LIBCPP_HIDE_FROM_ABI constexpr ~expected() 1061 requires(!is_trivially_destructible_v<_Err>) 1062 { 1063 if (!__has_val_) { 1064 std::destroy_at(std::addressof(__union_.__unex_)); 1065 } 1066 } 1067 1068 // [expected.void.assign], assignment 1069 1070 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete; 1071 1072 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) 1073 noexcept(is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened 1074 requires(is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>) 1075 { 1076 if (__has_val_) { 1077 if (!__rhs.__has_val_) { 1078 std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_); 1079 __has_val_ = false; 1080 } 1081 } else { 1082 if (__rhs.__has_val_) { 1083 std::destroy_at(std::addressof(__union_.__unex_)); 1084 __has_val_ = true; 1085 } else { 1086 __union_.__unex_ = __rhs.__union_.__unex_; 1087 } 1088 } 1089 return *this; 1090 } 1091 1092 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&&) = delete; 1093 1094 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs) 1095 noexcept(is_nothrow_move_assignable_v<_Err> && 1096 is_nothrow_move_constructible_v<_Err>) 1097 requires(is_move_assignable_v<_Err> && 1098 is_move_constructible_v<_Err>) 1099 { 1100 if (__has_val_) { 1101 if (!__rhs.__has_val_) { 1102 std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_)); 1103 __has_val_ = false; 1104 } 1105 } else { 1106 if (__rhs.__has_val_) { 1107 std::destroy_at(std::addressof(__union_.__unex_)); 1108 __has_val_ = true; 1109 } else { 1110 __union_.__unex_ = std::move(__rhs.__union_.__unex_); 1111 } 1112 } 1113 return *this; 1114 } 1115 1116 template <class _OtherErr> 1117 requires(is_constructible_v<_Err, const _OtherErr&> && is_assignable_v<_Err&, const _OtherErr&>) 1118 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) { 1119 if (__has_val_) { 1120 std::construct_at(std::addressof(__union_.__unex_), __un.error()); 1121 __has_val_ = false; 1122 } else { 1123 __union_.__unex_ = __un.error(); 1124 } 1125 return *this; 1126 } 1127 1128 template <class _OtherErr> 1129 requires(is_constructible_v<_Err, _OtherErr> && is_assignable_v<_Err&, _OtherErr>) 1130 _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) { 1131 if (__has_val_) { 1132 std::construct_at(std::addressof(__union_.__unex_), std::move(__un.error())); 1133 __has_val_ = false; 1134 } else { 1135 __union_.__unex_ = std::move(__un.error()); 1136 } 1137 return *this; 1138 } 1139 1140 _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept { 1141 if (!__has_val_) { 1142 std::destroy_at(std::addressof(__union_.__unex_)); 1143 __has_val_ = true; 1144 } 1145 } 1146 1147 // [expected.void.swap], swap 1148 _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs) 1149 noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>) 1150 requires(is_swappable_v<_Err> && is_move_constructible_v<_Err>) 1151 { 1152 auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) { 1153 std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_)); 1154 std::destroy_at(std::addressof(__with_err.__union_.__unex_)); 1155 __with_val.__has_val_ = false; 1156 __with_err.__has_val_ = true; 1157 }; 1158 1159 if (__has_val_) { 1160 if (!__rhs.__has_val_) { 1161 __swap_val_unex_impl(*this, __rhs); 1162 } 1163 } else { 1164 if (__rhs.__has_val_) { 1165 __swap_val_unex_impl(__rhs, *this); 1166 } else { 1167 using std::swap; 1168 swap(__union_.__unex_, __rhs.__union_.__unex_); 1169 } 1170 } 1171 } 1172 1173 _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) 1174 noexcept(noexcept(__x.swap(__y))) 1175 requires requires { __x.swap(__y); } 1176 { 1177 __x.swap(__y); 1178 } 1179 1180 // [expected.void.obs], observers 1181 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; } 1182 1183 _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; } 1184 1185 _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept { 1186 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__has_val_, "expected::operator* requires the expected to contain a value"); 1187 } 1188 1189 _LIBCPP_HIDE_FROM_ABI constexpr void value() const& { 1190 if (!__has_val_) { 1191 std::__throw_bad_expected_access<_Err>(__union_.__unex_); 1192 } 1193 } 1194 1195 _LIBCPP_HIDE_FROM_ABI constexpr void value() && { 1196 if (!__has_val_) { 1197 std::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_)); 1198 } 1199 } 1200 1201 _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { 1202 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 1203 return __union_.__unex_; 1204 } 1205 1206 _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { 1207 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 1208 return __union_.__unex_; 1209 } 1210 1211 _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { 1212 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 1213 return std::move(__union_.__unex_); 1214 } 1215 1216 _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { 1217 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!__has_val_, "expected::error requires the expected to contain an error"); 1218 return std::move(__union_.__unex_); 1219 } 1220 1221 template <class _Up = _Err> 1222 _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) const& { 1223 static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible"); 1224 static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); 1225 if (has_value()) { 1226 return std::forward<_Up>(__error); 1227 } 1228 return error(); 1229 } 1230 1231 template <class _Up = _Err> 1232 _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __error) && { 1233 static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible"); 1234 static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type"); 1235 if (has_value()) { 1236 return std::forward<_Up>(__error); 1237 } 1238 return std::move(error()); 1239 } 1240 1241 // [expected.void.monadic], monadic 1242 template <class _Func> 1243 requires is_constructible_v<_Err, _Err&> 1244 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & { 1245 using _Up = remove_cvref_t<invoke_result_t<_Func>>; 1246 static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); 1247 static_assert( 1248 is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); 1249 if (has_value()) { 1250 return std::invoke(std::forward<_Func>(__f)); 1251 } 1252 return _Up(unexpect, error()); 1253 } 1254 1255 template <class _Func> 1256 requires is_constructible_v<_Err, const _Err&> 1257 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& { 1258 using _Up = remove_cvref_t<invoke_result_t<_Func>>; 1259 static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); 1260 static_assert( 1261 is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); 1262 if (has_value()) { 1263 return std::invoke(std::forward<_Func>(__f)); 1264 } 1265 return _Up(unexpect, error()); 1266 } 1267 1268 template <class _Func> 1269 requires is_constructible_v<_Err, _Err&&> 1270 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && { 1271 using _Up = remove_cvref_t<invoke_result_t<_Func>>; 1272 static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); 1273 static_assert( 1274 is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); 1275 if (has_value()) { 1276 return std::invoke(std::forward<_Func>(__f)); 1277 } 1278 return _Up(unexpect, std::move(error())); 1279 } 1280 1281 template <class _Func> 1282 requires is_constructible_v<_Err, const _Err&&> 1283 _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& { 1284 using _Up = remove_cvref_t<invoke_result_t<_Func>>; 1285 static_assert(__is_std_expected<_Up>::value, "The result of f() must be a specialization of std::expected"); 1286 static_assert( 1287 is_same_v<typename _Up::error_type, _Err>, "The result of f() must have the same error_type as this expected"); 1288 if (has_value()) { 1289 return std::invoke(std::forward<_Func>(__f)); 1290 } 1291 return _Up(unexpect, std::move(error())); 1292 } 1293 1294 template <class _Func> 1295 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & { 1296 using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&>>; 1297 static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); 1298 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 1299 "The result of f(error()) must have the same value_type as this expected"); 1300 if (has_value()) { 1301 return _Gp(); 1302 } 1303 return std::invoke(std::forward<_Func>(__f), error()); 1304 } 1305 1306 template <class _Func> 1307 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& { 1308 using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&>>; 1309 static_assert(__is_std_expected<_Gp>::value, "The result of f(error()) must be a specialization of std::expected"); 1310 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 1311 "The result of f(error()) must have the same value_type as this expected"); 1312 if (has_value()) { 1313 return _Gp(); 1314 } 1315 return std::invoke(std::forward<_Func>(__f), error()); 1316 } 1317 1318 template <class _Func> 1319 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && { 1320 using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>; 1321 static_assert(__is_std_expected<_Gp>::value, 1322 "The result of f(std::move(error())) must be a specialization of std::expected"); 1323 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 1324 "The result of f(std::move(error())) must have the same value_type as this expected"); 1325 if (has_value()) { 1326 return _Gp(); 1327 } 1328 return std::invoke(std::forward<_Func>(__f), std::move(error())); 1329 } 1330 1331 template <class _Func> 1332 _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& { 1333 using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>; 1334 static_assert(__is_std_expected<_Gp>::value, 1335 "The result of f(std::move(error())) must be a specialization of std::expected"); 1336 static_assert(is_same_v<typename _Gp::value_type, _Tp>, 1337 "The result of f(std::move(error())) must have the same value_type as this expected"); 1338 if (has_value()) { 1339 return _Gp(); 1340 } 1341 return std::invoke(std::forward<_Func>(__f), std::move(error())); 1342 } 1343 1344 template <class _Func> 1345 requires is_constructible_v<_Err, _Err&> 1346 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & { 1347 using _Up = remove_cv_t<invoke_result_t<_Func>>; 1348 if (!has_value()) { 1349 return expected<_Up, _Err>(unexpect, error()); 1350 } 1351 if constexpr (!is_void_v<_Up>) { 1352 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); 1353 } else { 1354 std::invoke(std::forward<_Func>(__f)); 1355 return expected<_Up, _Err>(); 1356 } 1357 } 1358 1359 template <class _Func> 1360 requires is_constructible_v<_Err, const _Err&> 1361 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& { 1362 using _Up = remove_cv_t<invoke_result_t<_Func>>; 1363 if (!has_value()) { 1364 return expected<_Up, _Err>(unexpect, error()); 1365 } 1366 if constexpr (!is_void_v<_Up>) { 1367 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); 1368 } else { 1369 std::invoke(std::forward<_Func>(__f)); 1370 return expected<_Up, _Err>(); 1371 } 1372 } 1373 1374 template <class _Func> 1375 requires is_constructible_v<_Err, _Err&&> 1376 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && { 1377 using _Up = remove_cv_t<invoke_result_t<_Func>>; 1378 if (!has_value()) { 1379 return expected<_Up, _Err>(unexpect, std::move(error())); 1380 } 1381 if constexpr (!is_void_v<_Up>) { 1382 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); 1383 } else { 1384 std::invoke(std::forward<_Func>(__f)); 1385 return expected<_Up, _Err>(); 1386 } 1387 } 1388 1389 template <class _Func> 1390 requires is_constructible_v<_Err, const _Err&&> 1391 _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& { 1392 using _Up = remove_cv_t<invoke_result_t<_Func>>; 1393 if (!has_value()) { 1394 return expected<_Up, _Err>(unexpect, std::move(error())); 1395 } 1396 if constexpr (!is_void_v<_Up>) { 1397 return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f)); 1398 } else { 1399 std::invoke(std::forward<_Func>(__f)); 1400 return expected<_Up, _Err>(); 1401 } 1402 } 1403 1404 template <class _Func> 1405 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & { 1406 using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&>>; 1407 static_assert(__valid_std_unexpected<_Gp>::value, 1408 "The result of f(error()) must be a valid template argument for unexpected"); 1409 if (has_value()) { 1410 return expected<_Tp, _Gp>(); 1411 } 1412 return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); 1413 } 1414 1415 template <class _Func> 1416 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& { 1417 using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&>>; 1418 static_assert(__valid_std_unexpected<_Gp>::value, 1419 "The result of f(error()) must be a valid template argument for unexpected"); 1420 if (has_value()) { 1421 return expected<_Tp, _Gp>(); 1422 } 1423 return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error()); 1424 } 1425 1426 template <class _Func> 1427 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && { 1428 using _Gp = remove_cv_t<invoke_result_t<_Func, _Err&&>>; 1429 static_assert(__valid_std_unexpected<_Gp>::value, 1430 "The result of f(std::move(error())) must be a valid template argument for unexpected"); 1431 if (has_value()) { 1432 return expected<_Tp, _Gp>(); 1433 } 1434 return expected<_Tp, _Gp>( 1435 __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); 1436 } 1437 1438 template <class _Func> 1439 _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& { 1440 using _Gp = remove_cv_t<invoke_result_t<_Func, const _Err&&>>; 1441 static_assert(__valid_std_unexpected<_Gp>::value, 1442 "The result of f(std::move(error())) must be a valid template argument for unexpected"); 1443 if (has_value()) { 1444 return expected<_Tp, _Gp>(); 1445 } 1446 return expected<_Tp, _Gp>( 1447 __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error())); 1448 } 1449 1450 // [expected.void.eq], equality operators 1451 template <class _T2, class _E2> 1452 requires is_void_v<_T2> 1453 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) { 1454 if (__x.__has_val_ != __y.__has_val_) { 1455 return false; 1456 } else { 1457 return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.__union_.__unex_); 1458 } 1459 } 1460 1461 template <class _E2> 1462 _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __y) { 1463 return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error()); 1464 } 1465 1466 private: 1467 struct __empty_t {}; 1468 1469 template <class _ErrorType> 1470 union __union_t { 1471 _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {} 1472 1473 template <class... _Args> 1474 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::unexpect_t, _Args&&... __args) 1475 : __unex_(std::forward<_Args>(__args)...) {} 1476 1477 template <class _Func, class... _Args> 1478 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 1479 __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) 1480 : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 1481 1482 template <class _Union> 1483 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(bool __has_val, _Union&& __other) { 1484 if (__has_val) 1485 std::construct_at(std::addressof(__empty_)); 1486 else 1487 std::construct_at(std::addressof(__unex_), std::forward<_Union>(__other).__unex_); 1488 } 1489 1490 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 1491 requires(is_trivially_destructible_v<_ErrorType>) 1492 = default; 1493 1494 // the expected's destructor handles this 1495 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {} 1496 1497 __empty_t __empty_; 1498 _ErrorType __unex_; 1499 }; 1500 1501 // use named union because [[no_unique_address]] cannot be applied to an unnamed union, 1502 // also guaranteed elision into a potentially-overlapping subobject is unsettled (and 1503 // it's not clear that it's implementable, given that the function is allowed to clobber 1504 // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107. 1505 template <class _ErrorType> 1506 requires is_trivially_move_constructible_v<_ErrorType> 1507 union __union_t<_ErrorType> { 1508 _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {} 1509 _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = default; 1510 _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = default; 1511 1512 template <class... _Args> 1513 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(std::unexpect_t, _Args&&... __args) 1514 : __unex_(std::forward<_Args>(__args)...) {} 1515 1516 template <class _Func, class... _Args> 1517 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t( 1518 __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args) 1519 : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {} 1520 1521 template <class _Union> 1522 _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(bool __has_val, _Union&& __other) { 1523 if (__has_val) 1524 std::construct_at(std::addressof(__empty_)); 1525 else 1526 std::construct_at(std::addressof(__unex_), std::forward<_Union>(__other).__unex_); 1527 } 1528 1529 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 1530 requires(is_trivially_destructible_v<_ErrorType>) 1531 = default; 1532 1533 // the expected's destructor handles this 1534 _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() 1535 requires(!is_trivially_destructible_v<_ErrorType>) 1536 {} 1537 1538 _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_; 1539 _LIBCPP_NO_UNIQUE_ADDRESS _ErrorType __unex_; 1540 }; 1541 1542 _LIBCPP_NO_UNIQUE_ADDRESS __union_t<_Err> __union_; 1543 bool __has_val_; 1544 }; 1545 1546 _LIBCPP_END_NAMESPACE_STD 1547 1548 #endif // _LIBCPP_STD_VER >= 23 1549 1550 _LIBCPP_POP_MACROS 1551 1552 #endif // _LIBCPP___EXPECTED_EXPECTED_H 1553