[libc++] Implement `std::expected` P0323R12
Implement `std::expected` https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0323r12.html
Added tests
Differential Revision: https://reviews.llvm.org/D124516
address comment
NOKEYCHECK=True
GitOrigin-RevId: e356f681f6c46ac35f933dc0cef3b25ceee8b210
diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt
index 7dc3ffa..1c8ce89 100644
--- a/include/CMakeLists.txt
+++ b/include/CMakeLists.txt
@@ -269,6 +269,10 @@
__debug
__debug_utils/randomize_range.h
__errc
+ __expected/bad_expected_access.h
+ __expected/expected.h
+ __expected/unexpect.h
+ __expected/unexpected.h
__filesystem/copy_options.h
__filesystem/directory_entry.h
__filesystem/directory_iterator.h
@@ -740,6 +744,7 @@
errno.h
exception
execution
+ expected
experimental/__config
experimental/__memory
experimental/algorithm
diff --git a/include/__expected/bad_expected_access.h b/include/__expected/bad_expected_access.h
new file mode 100644
index 0000000..361eab4
--- /dev/null
+++ b/include/__expected/bad_expected_access.h
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+#define _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+
+#include <__config>
+#include <__utility/move.h>
+
+#include <exception>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Err>
+class bad_expected_access;
+
+template <>
+class bad_expected_access<void> : public exception {
+protected:
+ _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept = default;
+ _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&) = default;
+ _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&) = default;
+ _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) = default;
+ _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&) = default;
+ ~bad_expected_access() override = default;
+
+public:
+ // The way this has been designed (by using a class template below) means that we'll already
+ // have a profusion of these vtables in TUs, and the dynamic linker will already have a bunch
+ // of work to do. So it is not worth hiding the <void> specialization in the dylib, given that
+ // it adds deployment target restrictions.
+ const char* what() const noexcept override { return "bad access to std::expected"; }
+};
+
+template <class _Err>
+class bad_expected_access : public bad_expected_access<void> {
+public:
+ _LIBCPP_HIDE_FROM_ABI explicit bad_expected_access(_Err __e) : __unex_(std::move(__e)) {}
+
+ _LIBCPP_HIDE_FROM_ABI _Err& error() & noexcept { return __unex_; }
+ _LIBCPP_HIDE_FROM_ABI const _Err& error() const& noexcept { return __unex_; }
+ _LIBCPP_HIDE_FROM_ABI _Err&& error() && noexcept { return std::move(__unex_); }
+ _LIBCPP_HIDE_FROM_ABI const _Err&& error() const&& noexcept { return std::move(__unex_); }
+
+private:
+ _Err __unex_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
diff --git a/include/__expected/expected.h b/include/__expected/expected.h
new file mode 100644
index 0000000..593ec4b
--- /dev/null
+++ b/include/__expected/expected.h
@@ -0,0 +1,971 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_EXPECTED_H
+#define _LIBCPP___EXPECTED_EXPECTED_H
+
+#include <__assert>
+#include <__config>
+#include <__expected/bad_expected_access.h>
+#include <__expected/unexpect.h>
+#include <__expected/unexpected.h>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/disjunction.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_copy_assignable.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_default_constructible.h>
+#include <__type_traits/is_function.h>
+#include <__type_traits/is_move_assignable.h>
+#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_nothrow_copy_assignable.h>
+#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_void.h>
+#include <__type_traits/lazy.h>
+#include <__type_traits/negation.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+#include <__utility/transaction.h>
+#include <cstdlib> // for std::abort
+#include <initializer_list>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __expected {
+
+template <class _Err, class _Arg>
+_LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
+# ifndef _LIBCPP_NO_EXCEPTIONS
+ throw bad_expected_access<_Err>(std::forward<_Arg>(__arg));
+# else
+ (void)__arg;
+ std::abort();
+# endif
+}
+
+} // namespace __expected
+
+template <class _Tp, class _Err>
+class expected {
+ static_assert(
+ !is_reference_v<_Tp> &&
+ !is_function_v<_Tp> &&
+ !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
+ !is_same_v<remove_cv_t<_Tp>, unexpect_t> &&
+ !__unexpected::__is_unexpected<remove_cv_t<_Tp>>::value &&
+ __unexpected::__valid_unexpected<_Err>::value
+ ,
+ "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
+ "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
+ "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
+ "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
+ "template argument for unexpected is ill-formed.");
+
+ template <class _Up, class _OtherErr>
+ friend class expected;
+
+public:
+ using value_type = _Tp;
+ using error_type = _Err;
+ using unexpected_type = unexpected<_Err>;
+
+ template <class _Up>
+ using rebind = expected<_Up, error_type>;
+
+ // [expected.object.ctor], constructors
+ _LIBCPP_HIDE_FROM_ABI constexpr expected()
+ noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened
+ requires is_default_constructible_v<_Tp>
+ : __has_val_(true) {
+ std::construct_at(std::addressof(__union_.__val_));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&)
+ requires(is_copy_constructible_v<_Tp> &&
+ is_copy_constructible_v<_Err> &&
+ is_trivially_copy_constructible_v<_Tp> &&
+ is_trivially_copy_constructible_v<_Err>)
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other)
+ noexcept(is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened
+ requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> &&
+ !(is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>))
+ : __has_val_(__other.__has_val_) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
+ } else {
+ std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
+ }
+ }
+
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
+ requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err>
+ && is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other)
+ noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>)
+ requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> &&
+ !(is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>))
+ : __has_val_(__other.__has_val_) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
+ } else {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
+ }
+ }
+
+private:
+ template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual>
+ using __can_convert =
+ _And< is_constructible<_Tp, _UfQual>,
+ is_constructible<_Err, _OtherErrQual>,
+ _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>,
+ _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>,
+ _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>,
+ _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>,
+ _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>,
+ _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>,
+ _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
+ _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >;
+
+
+public:
+ template <class _Up, class _OtherErr>
+ requires __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Up&, _Tp> ||
+ !is_convertible_v<const _OtherErr&, _Err>)
+ expected(const expected<_Up, _OtherErr>& __other)
+ noexcept(is_nothrow_constructible_v<_Tp, const _Up&> &&
+ is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+ : __has_val_(__other.__has_val_) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
+ } else {
+ std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
+ }
+ }
+
+ template <class _Up, class _OtherErr>
+ requires __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp> || !is_convertible_v<_OtherErr, _Err>)
+ expected(expected<_Up, _OtherErr>&& __other)
+ noexcept(is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+ : __has_val_(__other.__has_val_) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
+ } else {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
+ }
+ }
+
+ template <class _Up = _Tp>
+ requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> &&
+ !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value && is_constructible_v<_Tp, _Up>)
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>)
+ expected(_Up&& __u)
+ noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
+ : __has_val_(true) {
+ std::construct_at(std::addressof(__union_.__val_), std::forward<_Up>(__u));
+ }
+
+
+ template <class _OtherErr>
+ requires is_constructible_v<_Err, const _OtherErr&>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
+ expected(const unexpected<_OtherErr>& __unex)
+ noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), __unex.error());
+ }
+
+ template <class _OtherErr>
+ requires is_constructible_v<_Err, _OtherErr>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
+ expected(unexpected<_OtherErr>&& __unex)
+ noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<_Tp, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Tp, _Args...>) // strengthened
+ : __has_val_(true) {
+ std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Up, class... _Args>
+ requires is_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit
+ expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened
+ : __has_val_(true) {
+ std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
+ }
+
+ template <class... _Args>
+ requires is_constructible_v<_Err, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Up, class... _Args>
+ requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit
+ expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
+ }
+
+ // [expected.object.dtor], destructor
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+ requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+ requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
+ {
+ if (__has_val_) {
+ std::destroy_at(std::addressof(__union_.__val_));
+ } else {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ }
+ }
+
+private:
+ template <class _T1, class _T2, class... _Args>
+ _LIBCPP_HIDE_FROM_ABI static constexpr void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) {
+ if constexpr (is_nothrow_constructible_v<_T1, _Args...>) {
+ std::destroy_at(std::addressof(__oldval));
+ std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+ } else if constexpr (is_nothrow_move_constructible_v<_T1>) {
+ _T1 __tmp(std::forward<_Args>(__args)...);
+ std::destroy_at(std::addressof(__oldval));
+ std::construct_at(std::addressof(__newval), std::move(__tmp));
+ } else {
+ static_assert(
+ is_nothrow_move_constructible_v<_T2>,
+ "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can "
+ "be reverted to the previous state in case an exception is thrown during the assignment.");
+ _T2 __tmp(std::move(__oldval));
+ std::destroy_at(std::addressof(__oldval));
+ __transaction __trans([&] { std::construct_at(std::addressof(__oldval), std::move(__tmp)); });
+ std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+ __trans.__complete();
+ }
+ }
+
+public:
+ // [expected.object.assign], assignment
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
+ noexcept(is_nothrow_copy_assignable_v<_Tp> &&
+ is_nothrow_copy_constructible_v<_Tp> &&
+ is_nothrow_copy_assignable_v<_Err> &&
+ is_nothrow_copy_constructible_v<_Err>) // strengthened
+ requires(is_copy_assignable_v<_Tp> &&
+ is_copy_constructible_v<_Tp> &&
+ is_copy_assignable_v<_Err> &&
+ is_copy_constructible_v<_Err> &&
+ (is_nothrow_move_constructible_v<_Tp> ||
+ is_nothrow_move_constructible_v<_Err>))
+ {
+ if (__has_val_ && __rhs.__has_val_) {
+ __union_.__val_ = __rhs.__union_.__val_;
+ } else if (__has_val_) {
+ __reinit_expected(__union_.__unex_, __union_.__val_, __rhs.__union_.__unex_);
+ } else if (__rhs.__has_val_) {
+ __reinit_expected(__union_.__val_, __union_.__unex_, __rhs.__union_.__val_);
+ } else {
+ __union_.__unex_ = __rhs.__union_.__unex_;
+ }
+ // note: only reached if no exception+rollback was done inside __reinit_expected
+ __has_val_ = __rhs.__has_val_;
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
+ noexcept(is_nothrow_move_assignable_v<_Tp> &&
+ is_nothrow_move_constructible_v<_Tp> &&
+ is_nothrow_move_assignable_v<_Err> &&
+ is_nothrow_move_constructible_v<_Err>)
+ requires(is_move_constructible_v<_Tp> &&
+ is_move_assignable_v<_Tp> &&
+ is_move_constructible_v<_Err> &&
+ is_move_assignable_v<_Err> &&
+ (is_nothrow_move_constructible_v<_Tp> ||
+ is_nothrow_move_constructible_v<_Err>))
+ {
+ if (__has_val_ && __rhs.__has_val_) {
+ __union_.__val_ = std::move(__rhs.__union_.__val_);
+ } else if (__has_val_) {
+ __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__rhs.__union_.__unex_));
+ } else if (__rhs.__has_val_) {
+ __reinit_expected(__union_.__val_, __union_.__unex_, std::move(__rhs.__union_.__val_));
+ } else {
+ __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+ }
+ // note: only reached if no exception+rollback was done inside __reinit_expected
+ __has_val_ = __rhs.__has_val_;
+ return *this;
+ }
+
+ template <class _Up = _Tp>
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v)
+ requires(!is_same_v<expected, remove_cvref_t<_Up>> &&
+ !__unexpected::__is_unexpected<remove_cvref_t<_Up>>::value &&
+ is_constructible_v<_Tp, _Up> &&
+ is_assignable_v<_Tp&, _Up> &&
+ (is_nothrow_constructible_v<_Tp, _Up> ||
+ is_nothrow_move_constructible_v<_Tp> ||
+ is_nothrow_move_constructible_v<_Err>))
+ {
+ if (__has_val_) {
+ __union_.__val_ = std::forward<_Up>(__v);
+ } else {
+ __reinit_expected(__union_.__val_, __union_.__unex_, std::forward<_Up>(__v));
+ __has_val_ = true;
+ }
+ return *this;
+ }
+
+private:
+ template <class _OtherErrQual>
+ static constexpr bool __can_assign_from_unexpected =
+ _And< is_constructible<_Err, _OtherErrQual>,
+ is_assignable<_Err&, _OtherErrQual>,
+ _Lazy<_Or,
+ is_nothrow_constructible<_Err, _OtherErrQual>,
+ is_nothrow_move_constructible<_Tp>,
+ is_nothrow_move_constructible<_Err>> >::value;
+
+public:
+ template <class _OtherErr>
+ requires(__can_assign_from_unexpected<const _OtherErr&>)
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
+ if (__has_val_) {
+ __reinit_expected(__union_.__unex_, __union_.__val_, __un.error());
+ __has_val_ = false;
+ } else {
+ __union_.__unex_ = __un.error();
+ }
+ return *this;
+ }
+
+ template <class _OtherErr>
+ requires(__can_assign_from_unexpected<_OtherErr>)
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
+ if (__has_val_) {
+ __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__un.error()));
+ __has_val_ = false;
+ } else {
+ __union_.__unex_ = std::move(__un.error());
+ }
+ return *this;
+ }
+
+ template <class... _Args>
+ requires is_nothrow_constructible_v<_Tp, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(_Args&&... __args) noexcept {
+ if (__has_val_) {
+ std::destroy_at(std::addressof(__union_.__val_));
+ } else {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ __has_val_ = true;
+ }
+ return *std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Up, class... _Args>
+ requires is_nothrow_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept {
+ if (__has_val_) {
+ std::destroy_at(std::addressof(__union_.__val_));
+ } else {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ __has_val_ = true;
+ }
+ return *std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
+ }
+
+
+public:
+ // [expected.object.swap], swap
+ _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
+ noexcept(is_nothrow_move_constructible_v<_Tp> &&
+ is_nothrow_swappable_v<_Tp> &&
+ is_nothrow_move_constructible_v<_Err> &&
+ is_nothrow_swappable_v<_Err>)
+ requires(is_swappable_v<_Tp> &&
+ is_swappable_v<_Err> &&
+ is_move_constructible_v<_Tp> &&
+ is_move_constructible_v<_Err> &&
+ (is_nothrow_move_constructible_v<_Tp> ||
+ is_nothrow_move_constructible_v<_Err>))
+ {
+ auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
+ if constexpr (is_nothrow_move_constructible_v<_Err>) {
+ _Err __tmp(std::move(__with_err.__union_.__unex_));
+ std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+ __transaction __trans([&] {
+ std::construct_at(std::addressof(__with_err.__union_.__unex_), std::move(__tmp));
+ });
+ std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__with_val.__union_.__val_));
+ __trans.__complete();
+ std::destroy_at(std::addressof(__with_val.__union_.__val_));
+ std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__tmp));
+ } else {
+ static_assert(is_nothrow_move_constructible_v<_Tp>,
+ "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so "
+ "that it can be reverted to the previous state in case an exception is thrown during swap.");
+ _Tp __tmp(std::move(__with_val.__union_.__val_));
+ std::destroy_at(std::addressof(__with_val.__union_.__val_));
+ __transaction __trans([&] { std::construct_at(std::addressof(__with_val.__union_.__val_), std::move(__tmp)); });
+ std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
+ __trans.__complete();
+ std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+ std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__tmp));
+ }
+ __with_val.__has_val_ = false;
+ __with_err.__has_val_ = true;
+ };
+
+ if (__has_val_) {
+ if (__rhs.__has_val_) {
+ using std::swap;
+ swap(__union_.__val_, __rhs.__union_.__val_);
+ } else {
+ __swap_val_unex_impl(*this, __rhs);
+ }
+ } else {
+ if (__rhs.__has_val_) {
+ __swap_val_unex_impl(__rhs, *this);
+ } else {
+ using std::swap;
+ swap(__union_.__unex_, __rhs.__union_.__unex_);
+ }
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ requires requires { __x.swap(__y); }
+ {
+ __x.swap(__y);
+ }
+
+ // [expected.object.obs], observers
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
+ return std::addressof(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
+ return std::addressof(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+ return __union_.__val_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+ return __union_.__val_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+ return std::move(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+ return std::move(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& value() const& {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+ }
+ return __union_.__val_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+ }
+ return __union_.__val_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+ }
+ return std::move(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+ }
+ return std::move(__union_.__val_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return __union_.__unex_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return __union_.__unex_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return std::move(__union_.__unex_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return std::move(__union_.__unex_);
+ }
+
+ template <class _Up>
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
+ static_assert(is_copy_constructible_v<_Tp>, "value_type has to be copy constructible");
+ static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
+ return __has_val_ ? __union_.__val_ : static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+ template <class _Up>
+ _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
+ static_assert(is_move_constructible_v<_Tp>, "value_type has to be move constructible");
+ static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
+ return __has_val_ ? std::move(__union_.__val_) : static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+ // [expected.object.eq], equality operators
+ template <class _T2, class _E2>
+ requires(!is_void_v<_T2>)
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
+ if (__x.__has_val_ != __y.__has_val_) {
+ return false;
+ } else {
+ if (__x.__has_val_) {
+ return __x.__union_.__val_ == __y.__union_.__val_;
+ } else {
+ return __x.__union_.__unex_ == __y.__union_.__unex_;
+ }
+ }
+ }
+
+ template <class _T2>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const _T2& __v) {
+ return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
+ }
+
+ template <class _E2>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __e) {
+ return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error());
+ }
+
+private:
+ struct __empty_t {};
+ // use named union because [[no_unique_address]] cannot be applied to an unnamed union
+ _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
+ _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
+ requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
+ = default;
+
+ // the expected's destructor handles this
+ _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
+ requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
+ {}
+
+ _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
+ _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
+ _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
+ } __union_;
+
+ bool __has_val_;
+};
+
+template <class _Tp, class _Err>
+ requires is_void_v<_Tp>
+class expected<_Tp, _Err> {
+ static_assert(__unexpected::__valid_unexpected<_Err>::value,
+ "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a "
+ "valid argument for unexpected<E> is ill-formed");
+
+ template <class, class>
+ friend class expected;
+
+ template <class _Up, class _OtherErr, class _OtherErrQual>
+ using __can_convert =
+ _And< is_void<_Up>,
+ is_constructible<_Err, _OtherErrQual>,
+ _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
+ _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
+ _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>;
+
+public:
+ using value_type = _Tp;
+ using error_type = _Err;
+ using unexpected_type = unexpected<_Err>;
+
+ template <class _Up>
+ using rebind = expected<_Up, error_type>;
+
+ // [expected.void.ctor], constructors
+ _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __has_val_(true) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&)
+ requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>)
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs)
+ noexcept(is_nothrow_copy_constructible_v<_Err>) // strengthened
+ requires(is_copy_constructible_v<_Err> && !is_trivially_copy_constructible_v<_Err>)
+ : __has_val_(__rhs.__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
+ requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>)
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs)
+ noexcept(is_nothrow_move_constructible_v<_Err>)
+ requires(is_move_constructible_v<_Err> && !is_trivially_move_constructible_v<_Err>)
+ : __has_val_(__rhs.__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+ }
+ }
+
+ template <class _Up, class _OtherErr>
+ requires __can_convert<_Up, _OtherErr, const _OtherErr&>::value
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
+ expected(const expected<_Up, _OtherErr>& __rhs)
+ noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+ : __has_val_(__rhs.__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+ }
+ }
+
+ template <class _Up, class _OtherErr>
+ requires __can_convert<_Up, _OtherErr, _OtherErr>::value
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
+ expected(expected<_Up, _OtherErr>&& __rhs)
+ noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+ : __has_val_(__rhs.__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+ }
+ }
+
+ template <class _OtherErr>
+ requires is_constructible_v<_Err, const _OtherErr&>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
+ expected(const unexpected<_OtherErr>& __unex)
+ noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), __unex.error());
+ }
+
+ template <class _OtherErr>
+ requires is_constructible_v<_Err, _OtherErr>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
+ expected(unexpected<_OtherErr>&& __unex)
+ noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __has_val_(true) {}
+
+ template <class... _Args>
+ requires is_constructible_v<_Err, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
+ }
+
+ template <class _Up, class... _Args>
+ requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+ : __has_val_(false) {
+ std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
+ }
+
+ // [expected.void.dtor], destructor
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+ requires is_trivially_destructible_v<_Err>
+ = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+ requires(!is_trivially_destructible_v<_Err>)
+ {
+ if (!__has_val_) {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ }
+ }
+
+ // [expected.void.assign], assignment
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
+ noexcept(is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened
+ requires(is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>)
+ {
+ if (__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
+ __has_val_ = false;
+ }
+ } else {
+ if (__rhs.__has_val_) {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ __has_val_ = true;
+ } else {
+ __union_.__unex_ = __rhs.__union_.__unex_;
+ }
+ }
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&&) = delete;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
+ noexcept(is_nothrow_move_assignable_v<_Err> &&
+ is_nothrow_move_constructible_v<_Err>)
+ requires(is_move_assignable_v<_Err> &&
+ is_move_constructible_v<_Err>)
+ {
+ if (__has_val_) {
+ if (!__rhs.__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
+ __has_val_ = false;
+ }
+ } else {
+ if (__rhs.__has_val_) {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ __has_val_ = true;
+ } else {
+ __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+ }
+ }
+ return *this;
+ }
+
+ template <class _OtherErr>
+ requires(is_constructible_v<_Err, const _OtherErr&> && is_assignable_v<_Err&, const _OtherErr&>)
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), __un.error());
+ __has_val_ = false;
+ } else {
+ __union_.__unex_ = __un.error();
+ }
+ return *this;
+ }
+
+ template <class _OtherErr>
+ requires(is_constructible_v<_Err, _OtherErr> && is_assignable_v<_Err&, _OtherErr>)
+ _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
+ if (__has_val_) {
+ std::construct_at(std::addressof(__union_.__unex_), std::move(__un.error()));
+ __has_val_ = false;
+ } else {
+ __union_.__unex_ = std::move(__un.error());
+ }
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept {
+ if (!__has_val_) {
+ std::destroy_at(std::addressof(__union_.__unex_));
+ __has_val_ = true;
+ }
+ }
+
+ // [expected.void.swap], swap
+ _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
+ noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+ requires(is_swappable_v<_Err> && is_move_constructible_v<_Err>)
+ {
+ auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
+ std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
+ std::destroy_at(std::addressof(__with_err.__union_.__unex_));
+ __with_val.__has_val_ = false;
+ __with_err.__has_val_ = true;
+ };
+
+ if (__has_val_) {
+ if (!__rhs.__has_val_) {
+ __swap_val_unex_impl(*this, __rhs);
+ }
+ } else {
+ if (__rhs.__has_val_) {
+ __swap_val_unex_impl(__rhs, *this);
+ } else {
+ using std::swap;
+ swap(__union_.__unex_, __rhs.__union_.__unex_);
+ }
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ requires requires { __x.swap(__y); }
+ {
+ __x.swap(__y);
+ }
+
+ // [expected.void.obs], observers
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept {
+ _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void value() const& {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(__union_.__unex_);
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void value() && {
+ if (!__has_val_) {
+ __expected::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+ }
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return __union_.__unex_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return __union_.__unex_;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return std::move(__union_.__unex_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
+ _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
+ return std::move(__union_.__unex_);
+ }
+
+ // [expected.void.eq], equality operators
+ template <class _T2, class _E2>
+ requires is_void_v<_T2>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
+ if (__x.__has_val_ != __y.__has_val_) {
+ return false;
+ } else {
+ return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.__union_.__unex_);
+ }
+ }
+
+ template <class _E2>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __y) {
+ return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error());
+ }
+
+private:
+ struct __empty_t {};
+ // use named union because [[no_unique_address]] cannot be applied to an unnamed union
+ _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
+ _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
+ requires(is_trivially_destructible_v<_Err>)
+ = default;
+
+ // the expected's destructor handles this
+ _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
+ requires(!is_trivially_destructible_v<_Err>)
+ {}
+
+ _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
+ _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
+ } __union_;
+
+ bool __has_val_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_EXPECTED_H
diff --git a/include/__expected/unexpect.h b/include/__expected/unexpect.h
new file mode 100644
index 0000000..20bafc1
--- /dev/null
+++ b/include/__expected/unexpect.h
@@ -0,0 +1,32 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_UNEXPECT_H
+#define _LIBCPP___EXPECTED_UNEXPECT_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct unexpect_t {
+ _LIBCPP_HIDE_FROM_ABI explicit unexpect_t() = default;
+};
+
+inline constexpr unexpect_t unexpect{};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_UNEXPECT_H
diff --git a/include/__expected/unexpected.h b/include/__expected/unexpected.h
new file mode 100644
index 0000000..22c307d
--- /dev/null
+++ b/include/__expected/unexpected.h
@@ -0,0 +1,126 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___EXPECTED_UNEXPECTED_H
+#define _LIBCPP___EXPECTED_UNEXPECTED_H
+
+#include <__config>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/negation.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+#include <initializer_list>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Err>
+class unexpected;
+
+namespace __unexpected {
+
+template <class _Tp>
+struct __is_unexpected : false_type {};
+
+template <class _Err>
+struct __is_unexpected<unexpected<_Err>> : true_type {};
+
+template <class _Tp>
+using __valid_unexpected = _BoolConstant< //
+ is_object_v<_Tp> && //
+ !is_array_v<_Tp> && //
+ !__is_unexpected<_Tp>::value && //
+ !is_const_v<_Tp> && //
+ !is_volatile_v<_Tp> //
+ >;
+
+} // namespace __unexpected
+
+template <class _Err>
+class unexpected {
+ static_assert(__unexpected::__valid_unexpected<_Err>::value,
+ "[expected.un.general] states a program that instantiates std::unexpected for a non-object type, an "
+ "array type, a specialization of unexpected, or a cv-qualified type is ill-formed.");
+
+public:
+ _LIBCPP_HIDE_FROM_ABI constexpr unexpected(const unexpected&) = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr unexpected(unexpected&&) = default;
+
+ template <class _Error = _Err>
+ requires(!is_same_v<remove_cvref_t<_Error>, unexpected> && //
+ !is_same_v<remove_cvref_t<_Error>, in_place_t> && //
+ is_constructible_v<_Err, _Error>)
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(_Error&& __error) //
+ noexcept(is_nothrow_constructible_v<_Err, _Error>) // strengthened
+ : __unex_(std::forward<_Error>(__error)) {}
+
+ template <class... _Args>
+ requires is_constructible_v<_Err, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, _Args&&... __args) //
+ noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+ : __unex_(std::forward<_Args>(__args)...) {}
+
+ template <class _Up, class... _Args>
+ requires is_constructible_v<_Err, initializer_list<_Up>&, _Args...>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) //
+ noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+ : __unex_(__il, std::forward<_Args>(__args)...) {}
+
+ _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&) = default;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { return __unex_; }
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { return __unex_; }
+ _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { return std::move(__unex_); }
+ _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { return std::move(__unex_); }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Err>) {
+ static_assert(is_swappable_v<_Err>, "unexpected::swap requires is_swappable_v<E> to be true");
+ using std::swap;
+ swap(__unex_, __other.__unex_);
+ }
+
+ _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(unexpected& __x, unexpected& __y) noexcept(noexcept(__x.swap(__y)))
+ requires is_swappable_v<_Err>
+ {
+ __x.swap(__y);
+ }
+
+ template <class _Err2>
+ _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const unexpected& __x, const unexpected<_Err2>& __y) {
+ return __x.__unex_ == __y.__unex_;
+ }
+
+private:
+ _Err __unex_;
+};
+
+template <class _Err>
+unexpected(_Err) -> unexpected<_Err>;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___EXPECTED_UNEXPECTED_H
diff --git a/include/__type_traits/is_member_pointer.h b/include/__type_traits/is_member_pointer.h
index 8b4aff8..904d845 100644
--- a/include/__type_traits/is_member_pointer.h
+++ b/include/__type_traits/is_member_pointer.h
@@ -11,6 +11,7 @@
#include <__config>
#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_member_function_pointer.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
diff --git a/include/__type_traits/is_scalar.h b/include/__type_traits/is_scalar.h
index ee856db..b4dc70b 100644
--- a/include/__type_traits/is_scalar.h
+++ b/include/__type_traits/is_scalar.h
@@ -14,6 +14,7 @@
#include <__type_traits/is_arithmetic.h>
#include <__type_traits/is_enum.h>
#include <__type_traits/is_member_pointer.h>
+#include <__type_traits/is_null_pointer.h>
#include <__type_traits/is_pointer.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/include/__type_traits/is_void.h b/include/__type_traits/is_void.h
index 1c7ad83..d8ffdbd 100644
--- a/include/__type_traits/is_void.h
+++ b/include/__type_traits/is_void.h
@@ -11,6 +11,8 @@
#include <__config>
#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cv.h>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header
diff --git a/include/expected b/include/expected
new file mode 100644
index 0000000..486d0a2
--- /dev/null
+++ b/include/expected
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPECTED
+#define _LIBCPP_EXPECTED
+
+/*
+ Header <expected> synopsis
+
+namespace std {
+ // [expected.unexpected], class template unexpected
+ template<class E> class unexpected;
+
+ // [expected.bad], class template bad_expected_access
+ template<class E> class bad_expected_access;
+
+ // [expected.bad.void], specialization for void
+ template<> class bad_expected_access<void>;
+
+ // in-place construction of unexpected values
+ struct unexpect_t {
+ explicit unexpect_t() = default;
+ };
+ inline constexpr unexpect_t unexpect{};
+
+ // [expected.expected], class template expected
+ template<class T, class E> class expected;
+
+ // [expected.void], partial specialization of expected for void types
+ template<class T, class E> requires is_void_v<T> class expected<T, E>;
+}
+
+*/
+
+#include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
+#include <__expected/bad_expected_access.h>
+#include <__expected/expected.h>
+#include <__expected/unexpect.h>
+#include <__expected/unexpected.h>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#endif // _LIBCPP_EXPECTED
+
diff --git a/include/libcxx.imp b/include/libcxx.imp
index 07fc998..b2a018e 100644
--- a/include/libcxx.imp
+++ b/include/libcxx.imp
@@ -24,6 +24,7 @@
{ include: [ "@<__concepts/.*>", "private", "<concepts>", "public" ] },
{ include: [ "@<__coroutine/.*>", "private", "<coroutine>", "public" ] },
{ include: [ "@<__debug_utils/.*>", "private", "<debug_utils>", "public" ] },
+ { include: [ "@<__expected/.*>", "private", "<expected>", "public" ] },
{ include: [ "@<__filesystem/.*>", "private", "<filesystem>", "public" ] },
{ include: [ "@<__format/.*>", "private", "<format>", "public" ] },
{ include: [ "@<__functional/.*>", "private", "<functional>", "public" ] },
diff --git a/include/module.modulemap.in b/include/module.modulemap.in
index 4033d2f..e6481a8 100644
--- a/include/module.modulemap.in
+++ b/include/module.modulemap.in
@@ -785,6 +785,17 @@
header "execution"
export *
}
+ module expected {
+ header "expected"
+ export *
+
+ module __expected {
+ module bad_expected_access { private header "__expected/bad_expected_access.h" }
+ module expected { private header "__expected/expected.h" }
+ module unexpect { private header "__expected/unexpect.h" }
+ module unexpected { private header "__expected/unexpected.h" }
+ }
+ }
module filesystem {
@requires_LIBCXX_ENABLE_FILESYSTEM@
header "filesystem"
diff --git a/include/version b/include/version
index 9443564..1d10392 100644
--- a/include/version
+++ b/include/version
@@ -82,6 +82,7 @@
__cpp_lib_exchange_function 201304L <utility>
__cpp_lib_execution 201902L <execution>
201603L // C++17
+__cpp_lib_expected 202202L <expected>
__cpp_lib_filesystem 201703L <filesystem>
__cpp_lib_format 202106L <format>
__cpp_lib_forward_like 202207L <utility>
@@ -390,6 +391,7 @@
# undef __cpp_lib_constexpr_memory
# define __cpp_lib_constexpr_memory 202202L
// # define __cpp_lib_constexpr_typeinfo 202106L
+# define __cpp_lib_expected 202202L
# define __cpp_lib_forward_like 202207L
// # define __cpp_lib_invoke_r 202106L
# define __cpp_lib_is_scoped_enum 202011L