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