[libcxx-commits] [libcxx] [libc++] Reimplement `optional<T&>` and granularize `<optional>` header (PR #199138)
William Tran-Viet via libcxx-commits
libcxx-commits at lists.llvm.org
Sun May 24 20:08:53 PDT 2026
https://github.com/smallp-o-p updated https://github.com/llvm/llvm-project/pull/199138
>From b585c6268ff4f1575a3fea98aa0db2e0a21b1bd6 Mon Sep 17 00:00:00 2001
From: William Tran-Viet <wtranviet at proton.me>
Date: Wed, 20 May 2026 20:14:31 -0400
Subject: [PATCH 1/2] Reimplement optional<T&> as a partial specialization
---
libcxx/include/optional | 347 +++++++++---------
.../optional.monadic/and_then.pass.cpp | 37 +-
.../optional.monadic/or_else.pass.cpp | 8 +
.../optional.monadic/transform.pass.cpp | 21 +-
.../optional_in_place_t.verify.cpp | 8 +-
.../optional_nullopt_t.verify.cpp | 11 +-
6 files changed, 245 insertions(+), 187 deletions(-)
diff --git a/libcxx/include/optional b/libcxx/include/optional
index f7e12f84beba0..424f5a5f58ca4 100644
--- a/libcxx/include/optional
+++ b/libcxx/include/optional
@@ -571,6 +571,14 @@ struct __optional_storage_base<_Tp, true> {
__convert_init_ref_val(std::forward<_UArg>(__uarg));
}
+# if _LIBCPP_STD_VER >= 23
+ template <class _Fp, class... _Args>
+ constexpr __optional_storage_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) {
+ _Tp& __r = std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...);
+ __value_ = std::addressof(__r);
+ }
+# endif
+
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
@@ -726,8 +734,8 @@ using __optional_sfinae_ctor_base_t _LIBCPP_NODEBUG =
template <class _Tp>
using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
- __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>) || is_lvalue_reference_v<_Tp>,
- (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>) || is_lvalue_reference_v<_Tp>>;
+ __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>),
+ (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>)>;
template <class _Tp>
class optional;
@@ -769,6 +777,7 @@ inline constexpr bool __is_constructible_for_optional_initializer_list_v =
# if _LIBCPP_STD_VER >= 26
template <class _Tp, class... _Args>
inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Args...> = false;
+
template <class _Tp, class _Arg>
inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Arg> =
is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>;
@@ -777,6 +786,17 @@ template <class _Tp, class _Up, class... _Args>
inline constexpr bool __is_constructible_for_optional_initializer_list_v<_Tp&, _Up, _Args...> = false;
# endif
+# if _LIBCPP_STD_VER >= 26
+template <class _Tp>
+static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp> || std::is_lvalue_reference_v<_Tp>;
+# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE \
+ "Result of f(value()) should be a valid contained type for optional"
+# else
+template <class _Tp>
+static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp>;
+# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE "Result of f(value()) should be an object type"
+# endif
+
template <class _Tp, class = void>
struct __optional_iterator_base : __optional_move_assign_base<_Tp> {
using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
@@ -878,9 +898,8 @@ public:
conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
private:
- static_assert(!is_same_v<__remove_cvref_t<_Tp>, in_place_t>,
- "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<__remove_cvref_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
+ static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
+ static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
# if _LIBCPP_STD_VER >= 26
static_assert(!is_rvalue_reference_v<_Tp>, "instantiation of optional with an rvalue reference type is ill-formed");
# else
@@ -889,16 +908,6 @@ private:
static_assert(is_destructible_v<_Tp>, "instantiation of optional with a non-destructible type is ill-formed");
static_assert(!is_array_v<_Tp>, "instantiation of optional with an array type is ill-formed");
-# if _LIBCPP_STD_VER >= 26
- template <class _Up>
- constexpr static bool __libcpp_opt_ref_ctor_deleted =
- is_lvalue_reference_v<_Tp> && reference_constructs_from_temporary_v<_Tp, _Up>;
-
- template <class _Up>
- constexpr static bool __ref_ctor_enabled =
- is_lvalue_reference_v<_Tp> && !reference_constructs_from_temporary_v<_Tp, _Up>;
-# endif
-
// LWG2756: conditionally explicit conversion from _Up
struct _CheckOptionalArgsConstructor {
template <class _Up>
@@ -984,117 +993,34 @@ public:
: __base(in_place, __il, std::forward<_Args>(__args)...) {}
template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
-# endif
- : __base(in_place, std::forward<_Up>(__v)) {
- }
+ _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
template <class _Up = remove_cv_t<_Tp>,
enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
-# endif
- : __base(in_place, std::forward<_Up>(__v)) {
- }
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
// LWG2756: conditionally explicit conversion from const optional<_Up>&
template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, const _Up&>)
-# endif
- {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
this->__construct_from(__v);
}
+
template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, const _Up&>)
-# endif
- {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
this->__construct_from(__v);
}
// LWG2756: conditionally explicit conversion from optional<_Up>&&
template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
-# endif
- {
- this->__construct_from(std::move(__v));
- }
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
-# endif
- {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
this->__construct_from(std::move(__v));
}
- // deleted optional<T&> constructors and additional optional<T&> constructors
-# if _LIBCPP_STD_VER >= 26
- // optional(U&&)
- template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<_Up>
- optional(_Up&&) = delete;
-
- template <class _Up = remove_cv_t<_Tp>,
- enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<_Up>
- explicit optional(_Up&&) = delete;
-
- // optional(optional<U>& rhs)
- template <class _Up>
- requires __ref_ctor_enabled<_Up&> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) && (!is_same_v<_Tp&, _Up>) &&
- is_constructible_v<_Tp&, _Up&>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
- optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) {
- this->__construct_from(__rhs);
- }
-
- template <class _Up>
- requires __libcpp_opt_ref_ctor_deleted<_Up&> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
- (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, _Up&>
- constexpr explicit optional(optional<_Up>& __rhs) noexcept = delete;
-
- // optional(const optional<U>&)
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<const _Up&>
- optional(const optional<_Up>&) = delete;
-
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<const _Up&>
- explicit optional(const optional<_Up>&) = delete;
-
- // optional(optional<U>&&)
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<_Up>
- optional(optional<_Up>&&) = delete;
-
template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
- requires __libcpp_opt_ref_ctor_deleted<_Up>
- explicit optional(optional<_Up>&&) = delete;
-
- // optional(const optional<U>&&)
- template <class _Up>
- requires __ref_ctor_enabled<const _Up> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
- (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, const _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(!is_convertible_v<const _Up, _Tp&>)
- optional(const optional<_Up>&& __v) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
this->__construct_from(std::move(__v));
}
- template <class _Up>
- requires __libcpp_opt_ref_ctor_deleted<const _Up> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
- (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, const _Up>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>&& __v) noexcept = delete;
-# endif
-
# if _LIBCPP_STD_VER >= 23
template <class _Tag,
class _Fp,
@@ -1117,8 +1043,7 @@ public:
enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Up>, optional>,
_Or<_IsNotSame<__remove_cvref_t<_Up>, _Tp>, _Not<is_scalar<_Tp>>>,
is_constructible<_Tp, _Up>,
- is_assignable<_Tp&, _Up>,
- is_object<_Tp>>::value,
+ is_assignable<_Tp&, _Up>>::value,
int> = 0>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
if (this->has_value())
@@ -1143,11 +1068,7 @@ public:
}
template <class... _Args, enable_if_t<__is_constructible_for_optional_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args)
-# if _LIBCPP_STD_VER >= 26
- noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp, _Args...>)
-# endif
- {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
reset();
this->__construct(std::forward<_Args>(__args)...);
return this->__get();
@@ -1162,12 +1083,8 @@ public:
return this->__get();
}
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional& __opt) noexcept(
- (is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)
-# if _LIBCPP_STD_VER >= 26
- || is_lvalue_reference_v<_Tp>
-# endif
- ) {
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+ swap(optional& __opt) noexcept((is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)) {
this->__swap(__opt);
}
@@ -1181,9 +1098,6 @@ public:
using __base::value;
template <class _Up = remove_cv_t<_Tp>>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
static_assert(is_copy_constructible_v<_Tp>, "optional<T>::value_or: T must be copy constructible");
static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
@@ -1191,9 +1105,6 @@ public:
}
template <class _Up = remove_cv_t<_Tp>>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
static_assert(is_move_constructible_v<_Tp>, "optional<T>::value_or: T must be move constructible");
static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
@@ -1202,9 +1113,6 @@ public:
# if _LIBCPP_STD_VER >= 23
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
using _Up = invoke_result_t<_Func, _Tp&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
@@ -1215,9 +1123,6 @@ public:
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
using _Up = invoke_result_t<_Func, const _Tp&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
@@ -1228,9 +1133,6 @@ public:
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
using _Up = invoke_result_t<_Func, _Tp&&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
@@ -1241,9 +1143,6 @@ public:
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
using _Up = invoke_result_t<_Func, const _Tp&&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
@@ -1254,60 +1153,48 @@ public:
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
if (*this)
return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
return optional<_Up>();
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
if (*this)
return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
return optional<_Up>();
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
if (*this)
return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
return optional<_Up>();
}
template <class _Func>
-# if _LIBCPP_STD_VER >= 26
- requires(is_object_v<_Tp>)
-# endif
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
if (*this)
return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
return optional<_Up>();
@@ -1316,9 +1203,6 @@ public:
template <invocable _Func>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
requires is_copy_constructible_v<_Tp>
-# if _LIBCPP_STD_VER >= 26
- && (is_object_v<_Tp>)
-# endif
{
static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
"Result of f() should be the same type as this optional");
@@ -1330,9 +1214,6 @@ public:
template <invocable _Func>
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
requires is_move_constructible_v<_Tp>
-# if _LIBCPP_STD_VER >= 26
- && (is_object_v<_Tp>)
-# endif
{
static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
"Result of f() should be the same type as this optional");
@@ -1343,24 +1224,136 @@ public:
# endif // _LIBCPP_STD_VER >= 23
using __base::reset;
+};
-// optional<T&> overloads
# if _LIBCPP_STD_VER >= 26
+template <class _Tp>
+class optional<_Tp&> : public __optional_iterator_base<_Tp&> {
+ using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp&>;
+
+ template <class _Up, class _QualUp>
+ static constexpr bool __check_optionalU_ctor =
+ !std::is_same_v<std::remove_cv_t<_Tp>, optional<_Up>> && !std::is_same_v<_Tp&, _Up> &&
+ std::is_constructible_v<_Tp&, _QualUp>;
+ static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
+ static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
+
+public:
+ using value_type = _Tp;
+
+ constexpr optional() noexcept = default;
+ constexpr optional(nullopt_t) noexcept {}
+ constexpr optional(const optional&) noexcept = default;
+
+ template <class _Arg>
+ requires(std::is_constructible_v<_Tp&, _Arg> && !std::reference_constructs_from_temporary_v<_Tp&, _Arg>)
+ constexpr explicit optional(in_place_t, _Arg&& __arg) : __base(in_place, std::forward<_Arg>(__arg)) {}
+
+ template <class _Up>
+ requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
+ is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>) optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>)
+ : __base(in_place, std::forward<_Up>(__v)) {}
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
+ constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
+ optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) {
+ this->__construct_from(__rhs);
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
+ constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
+ optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) {
+ this->__construct_from(__rhs);
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
+ this->__construct_from(std::move(__rhs));
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
+ constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
+ optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) {
+ this->__construct_from(std::move(__rhs));
+ }
+
+ template <class _Tag, class _Fp, class... _Args>
+ requires(std::is_same_v<_Tag, __optional_construct_from_invoke_tag>)
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
+ : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
+
+ // deleted overloads
+
+ template <class _Up>
+ requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
+ is_constructible_v<_Tp&, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up&> && std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
+ constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
+ optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up&> && std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
+ constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
+ optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up> && std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
+ constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
+ optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) = delete;
+
+ constexpr ~optional() = default;
+
+ using __base::__get;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(nullopt_t) noexcept {
+ reset();
+ return *this;
+ }
+
+ constexpr optional& operator=(const optional&) noexcept = default;
+
+ template <class _Up>
+ requires(is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr _Tp& emplace(_Up&& __u) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
+ this->__construct(std::forward<_Up>(__u));
+
+ return this->__get();
+ }
+
+ constexpr void swap(optional& __rhs) noexcept { this->__swap(__rhs); }
+
+ using __base::operator->;
+ using __base::operator*;
+ constexpr explicit operator bool() const noexcept { return has_value(); }
+ using __base::has_value;
+ using __base::value;
template <class _Up = remove_cvref_t<_Tp>>
- requires(is_lvalue_reference_v<_Tp> && is_object_v<__libcpp_remove_reference_t<_Tp>> &&
- !is_array_v<__libcpp_remove_reference_t<_Tp>>)
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decay_t<_Tp> value_or(_Up&& __v) const {
- static_assert(
- is_constructible_v<remove_cvref_t<_Tp>, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
- static_assert(
- is_convertible_v<_Up, remove_cvref_t<_Tp>>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
- return this->has_value() ? this->__get() : static_cast<remove_cvref_t<_Tp>>(std::forward<_Up>(__v));
+ requires(!std::is_array_v<_Tp> && std::is_object_v<_Tp>)
+ [[nodiscard]] constexpr decay_t<_Tp> value_or(_Up&& __v) const {
+ using _XTp = std::remove_cv_t<_Tp>;
+ static_assert(std::is_constructible_v<_XTp, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
+ static_assert(std::is_convertible_v<_Up, _XTp>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
+ return this->has_value() ? this->__get() : static_cast<_XTp>(std::forward<_Up>(__v));
}
template <class _Func>
- requires(is_lvalue_reference_v<_Tp>)
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const {
+ [[nodiscard]] constexpr auto and_then(_Func&& __f) const {
using _Up = invoke_result_t<_Func, _Tp&>;
static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
"Result of f(value()) must be a specialization of std::optional");
@@ -1370,30 +1363,30 @@ public:
}
template <class _Func>
- requires(is_lvalue_reference_v<_Tp>)
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>>
- transform(_Func&& __f) const {
- using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
+ [[nodiscard]] constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>> transform(_Func&& __f) const {
+ using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+
if (*this)
return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
return optional<_Up>();
}
template <invocable _Func>
- requires(is_lvalue_reference_v<_Tp>)
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const {
+ [[nodiscard]] constexpr optional or_else(_Func&& __f) const {
static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
"Result of f() should be the same type as this optional");
if (*this)
return *this;
return std::forward<_Func>(__f)();
}
-# endif
+
+ using __base::reset;
};
+# endif
template <class _Tp>
optional(_Tp) -> optional<_Tp>;
diff --git a/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp b/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp
index 93bbd74cd8678..e806cd8dd5343 100644
--- a/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp
@@ -261,8 +261,6 @@ constexpr bool test() {
#if TEST_STD_VER >= 26
constexpr bool test_ref() {
- // Test "overloads", only the const (no ref-qualifier) and_then() should be called
-
{ // &
// Without & qualifier on F's operator()
{
@@ -339,6 +337,41 @@ constexpr bool test_ref() {
assert(std::move(i).and_then(std::move(nl)) == std::nullopt);
}
}
+
+ {
+ int i = 1;
+ int j = 2;
+ {
+ std::optional<int&> o(i);
+ std::same_as<std::optional<int&>> decltype(auto) r = o.and_then([&](auto&& ii) {
+ ii += j;
+ return std::optional<int&>(ii);
+ });
+
+ assert(i == 3);
+ assert(r == 3);
+ }
+ {
+ const std::optional<int&> o(i);
+ std::same_as<std::optional<int&>> decltype(auto) r = o.and_then([&](auto&& ii) {
+ ii += j;
+ return std::optional<int&>(ii);
+ });
+
+ assert(i == 5);
+ assert(r == 5);
+ }
+ {
+ std::optional<int&> o{};
+ std::same_as<std::optional<int>> decltype(auto) r = o.and_then([&](auto&&) { return std::optional(1); });
+ assert(r == std::nullopt);
+ }
+ {
+ const std::optional<int&> o{};
+ std::same_as<std::optional<int>> decltype(auto) r = o.and_then([&](auto&&) { return std::optional(1); });
+ assert(r == std::nullopt);
+ }
+ }
return true;
}
#endif
diff --git a/libcxx/test/std/utilities/optional/optional.monadic/or_else.pass.cpp b/libcxx/test/std/utilities/optional/optional.monadic/or_else.pass.cpp
index 326013cd6557f..7252f0a8700df 100644
--- a/libcxx/test/std/utilities/optional/optional.monadic/or_else.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.monadic/or_else.pass.cpp
@@ -104,6 +104,14 @@ constexpr bool test() {
}) == i);
}
+ {
+ int j = 2;
+ std::optional<int&> opt;
+ std::same_as<std::optional<int&>> decltype(auto) o = opt.or_else([&] { return std::optional<int&>(j); });
+ assert(o == j);
+ assert(&(*o) == &j);
+ }
+
#endif
return true;
diff --git a/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp b/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp
index b8536b790f749..96303c5796f6d 100644
--- a/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp
@@ -204,8 +204,6 @@ constexpr bool test() {
#if TEST_STD_VER >= 26
constexpr bool test_ref() {
- // Test that no matter the ref qualifier on the object .transform() is invoked on, only the added
- // const (no ref-qualifier) overload is used
{
std::optional<int&> opt1;
std::same_as<std::optional<int>> decltype(auto) opt1r = opt1.transform([](int i) { return i + 2; });
@@ -229,7 +227,6 @@ constexpr bool test_ref() {
assert(*o2 == 4.0f);
}
- // &
{
// Without & qualifier on F's operator()
{
@@ -250,7 +247,6 @@ constexpr bool test_ref() {
assert(*o3 == 1);
}
}
- // const& overload
{
// Without & qualifier on F's operator()
{
@@ -308,6 +304,23 @@ constexpr bool test_ref() {
auto o6r = o6.transform([](int) { return 42; });
assert(!o6r);
}
+
+ {
+ int i = 42;
+ int j{43};
+
+ auto func = [&j](int&) -> int& { return j; };
+
+ std::optional<int&> opt{i};
+ std::same_as<std::optional<int&>> decltype(auto) o = opt.transform(func);
+ assert(o == j);
+ assert(&(*o) == &j);
+
+ std::same_as<std::optional<int&>> decltype(auto) o2 = std::as_const(opt).transform(func);
+ assert(o2 == j);
+ assert(&(*o2) == &j);
+ }
+
return true;
}
#endif
diff --git a/libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.verify.cpp b/libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.verify.cpp
index 20efef515c362..8731b0b37e9bc 100644
--- a/libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.verify.cpp
@@ -15,7 +15,13 @@
#include <optional>
+#include "test_macros.h"
+
void f() {
std::optional<std::in_place_t> opt; // expected-note {{requested here}}
- // expected-error at optional:* {{instantiation of optional with in_place_t is ill-formed}}
+ // expected-error@*:* 1 {{instantiation of optional with in_place_t is ill-formed}}
+#if TEST_STD_VER >= 26
+ std::optional<std::in_place_t&> opt1; // expected-note {{requested here}}
+ // expected-error@*:* 1 {{instantiation of optional with in_place_t is ill-formed}}
+#endif
}
diff --git a/libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.verify.cpp b/libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.verify.cpp
index f807da7470ae9..0054b05aa767c 100644
--- a/libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.verify.cpp
@@ -15,10 +15,15 @@
#include <optional>
+#include "test_macros.h"
+
void f() {
std::optional<std::nullopt_t> opt; // expected-note 1 {{requested here}}
std::optional<const std::nullopt_t> opt1; // expected-note 1 {{requested here}}
- std::optional<std::nullopt_t &> opt2; // expected-note 1 {{requested here}}
- std::optional<std::nullopt_t &&> opt3; // expected-note 1 {{requested here}}
- // expected-error at optional:* 4 {{instantiation of optional with nullopt_t is ill-formed}}
+ // expected-error@*:* 2 {{instantiation of optional with nullopt_t is ill-formed}}
+#if TEST_STD_VER >= 26
+ std::optional<std::nullopt_t&> opt2; // expected-note 1 {{requested here}}
+ std::optional<const std::nullopt_t&> opt3; // expected-note 1 {{requested here}}
+ // expected-error@*:* 2 {{instantiation of optional with nullopt_t is ill-formed}}
+#endif
}
>From 73e21aeb23622fc2065a0806c9fa8d017e125bbf Mon Sep 17 00:00:00 2001
From: William Tran-Viet <wtranviet at proton.me>
Date: Thu, 21 May 2026 20:10:13 -0400
Subject: [PATCH 2/2] Granularize <optional>
---
libcxx/include/CMakeLists.txt | 8 +
libcxx/include/__fwd/optional.h | 36 +
libcxx/include/__optional/common.h | 601 +++++++
libcxx/include/__optional/comparison.h | 346 ++++
libcxx/include/__optional/hash.h | 48 +
libcxx/include/__optional/nullopt_t.h | 40 +
libcxx/include/__optional/optional.h | 411 +++++
libcxx/include/__optional/optional_ref.h | 218 +++
libcxx/include/__optional/swap.h | 37 +
libcxx/include/module.modulemap.in | 19 +
libcxx/include/optional | 1442 +----------------
.../derive.pass.cpp | 1 +
.../optional.object.ctor/ctor.verify.cpp | 24 +-
.../optional.object.ctor/deduct.verify.cpp | 2 +-
...al_requires_destructible_object.verify.cpp | 26 +-
15 files changed, 1807 insertions(+), 1452 deletions(-)
create mode 100644 libcxx/include/__fwd/optional.h
create mode 100644 libcxx/include/__optional/common.h
create mode 100644 libcxx/include/__optional/comparison.h
create mode 100644 libcxx/include/__optional/hash.h
create mode 100644 libcxx/include/__optional/nullopt_t.h
create mode 100644 libcxx/include/__optional/optional.h
create mode 100644 libcxx/include/__optional/optional_ref.h
create mode 100644 libcxx/include/__optional/swap.h
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 4ca7653026e47..9ae05d1546339 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -466,6 +466,7 @@ set(files
__fwd/mdspan.h
__fwd/memory.h
__fwd/memory_resource.h
+ __fwd/optional.h
__fwd/ostream.h
__fwd/pair.h
__fwd/queue.h
@@ -659,6 +660,13 @@ set(files
__numeric/transform_exclusive_scan.h
__numeric/transform_inclusive_scan.h
__numeric/transform_reduce.h
+ __optional/common.h
+ __optional/comparison.h
+ __optional/hash.h
+ __optional/nullopt_t.h
+ __optional/optional.h
+ __optional/optional_ref.h
+ __optional/swap.h
__ostream/basic_ostream.h
__ostream/print.h
__ostream/put_character_sequence.h
diff --git a/libcxx/include/__fwd/optional.h b/libcxx/include/__fwd/optional.h
new file mode 100644
index 0000000000000..35a3d2ea11e74
--- /dev/null
+++ b/libcxx/include/__fwd/optional.h
@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// std::optional<T&>
+
+#ifndef _LIBCPP___FWD_OPTIONAL_H
+#define _LIBCPP___FWD_OPTIONAL_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class optional;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FWD_OPTIONAL_H
diff --git a/libcxx/include/__optional/common.h b/libcxx/include/__optional/common.h
new file mode 100644
index 0000000000000..108abaf05d961
--- /dev/null
+++ b/libcxx/include/__optional/common.h
@@ -0,0 +1,601 @@
+// -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// std::bad_optional_access
+// optional base classes
+
+#ifndef _LIBCPP_OPTIONAL_COMMON_H
+#define _LIBCPP_OPTIONAL_COMMON_H
+
+#include <__assert>
+#include <__config>
+#include <__exception/exception.h>
+#include <__functional/invoke.h>
+#include <__fwd/format.h>
+#include <__fwd/optional.h>
+#include <__iterator/bounded_iter.h>
+#include <__iterator/capacity_aware_iterator.h>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/enable_view.h>
+#include <__tuple/sfinae_helpers.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_destructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_assignable.h>
+#include <__type_traits/is_trivially_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/reference_constructs_from_temporary.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+#include <__verbose_abort>
+#include <initializer_list>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+namespace std // purposefully not using versioning namespace
+{
+
+class _LIBCPP_EXPORTED_FROM_ABI bad_optional_access : public exception {
+public:
+ bad_optional_access() _NOEXCEPT = default;
+ bad_optional_access(const bad_optional_access&) _NOEXCEPT = default;
+ bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
+ // Get the key function ~bad_optional_access() into the dylib
+ ~bad_optional_access() _NOEXCEPT override;
+ [[__nodiscard__]] const char* what() const _NOEXCEPT override;
+};
+} // namespace std
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+[[noreturn]] inline void __throw_bad_optional_access() {
+# if _LIBCPP_HAS_EXCEPTIONS
+ throw bad_optional_access();
+# else
+ _LIBCPP_VERBOSE_ABORT("bad_optional_access was thrown in -fno-exceptions mode");
+# endif
+}
+
+struct __optional_construct_from_invoke_tag {};
+
+template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
+struct __optional_destruct_base;
+
+template <class _Tp>
+struct __optional_destruct_base<_Tp, false> {
+ typedef _Tp value_type;
+ static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
+ union {
+ char __null_state_;
+ remove_cv_t<value_type> __val_;
+ };
+ bool __engaged_;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__optional_destruct_base() {
+ if (__engaged_)
+ __val_.~value_type();
+ }
+
+ constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
+
+ template <class... _Args>
+ constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
+ : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
+
+# if _LIBCPP_STD_VER >= 23
+ template <class _Fp, class... _Args>
+ constexpr explicit __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
+ : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
+# endif
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
+ if (__engaged_) {
+ __val_.~value_type();
+ __engaged_ = false;
+ }
+ }
+};
+
+template <class _Tp>
+struct __optional_destruct_base<_Tp, true> {
+ typedef _Tp value_type;
+ static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
+ union {
+ char __null_state_;
+ remove_cv_t<value_type> __val_;
+ };
+ bool __engaged_;
+
+ constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
+
+ template <class... _Args>
+ constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
+ : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
+
+# if _LIBCPP_STD_VER >= 23
+ template <class _Fp, class... _Args>
+ constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
+ : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
+# endif
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
+ if (__engaged_) {
+ __engaged_ = false;
+ }
+ }
+};
+
+template <class _Tp, bool = is_reference<_Tp>::value>
+struct __optional_storage_base : __optional_destruct_base<_Tp> {
+ using __base _LIBCPP_NODEBUG = __optional_destruct_base<_Tp>;
+ using value_type = _Tp;
+ using __base::__base;
+
+ [[nodiscard]] constexpr bool has_value() const noexcept { return this->__engaged_; }
+
+ constexpr value_type& __get() & noexcept { return this->__val_; }
+ constexpr const value_type& __get() const& noexcept { return this->__val_; }
+ constexpr value_type&& __get() && noexcept { return std::move(this->__val_); }
+ constexpr const value_type&& __get() const&& noexcept { return std::move(this->__val_); }
+
+ template <class... _Args>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args) {
+ _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
+ std::__construct_at(std::addressof(this->__val_), std::forward<_Args>(__args)...);
+ this->__engaged_ = true;
+ }
+
+ template <class _That>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
+ if (__opt.has_value())
+ __construct(std::forward<_That>(__opt).__get());
+ }
+
+ template <class _That>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
+ if (this->__engaged_ == __opt.has_value()) {
+ if (this->__engaged_)
+ static_cast<_Tp&>(this->__val_) = std::forward<_That>(__opt).__get();
+ } else {
+ if (this->__engaged_)
+ this->reset();
+ else
+ __construct(std::forward<_That>(__opt).__get());
+ }
+ }
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+ __swap(__optional_storage_base& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) {
+ using std::swap;
+ if (this->has_value() == __rhs.has_value()) {
+ if (this->has_value())
+ swap(this->__get(), __rhs.__get());
+ } else {
+ if (this->has_value()) {
+ __rhs.__construct(std::move(this->__get()));
+ this->reset();
+ } else {
+ this->__construct(std::move(__rhs.__get()));
+ __rhs.reset();
+ }
+ }
+ }
+
+ // [optional.observe]
+ constexpr add_pointer_t<_Tp const> operator->() const noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+ return std::addressof(this->__get());
+ }
+
+ constexpr add_pointer_t<_Tp> operator->() noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+ return std::addressof(this->__get());
+ }
+
+ [[nodiscard]] constexpr const _Tp& operator*() const& noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+ return this->__get();
+ }
+
+ [[nodiscard]] constexpr _Tp& operator*() & noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+ return this->__get();
+ }
+
+ [[nodiscard]] constexpr _Tp&& operator*() && noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+ return std::move(this->__get());
+ }
+
+ [[nodiscard]] constexpr const _Tp&& operator*() const&& noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+ return std::move(this->__get());
+ }
+
+ [[nodiscard]] constexpr _Tp const& value() const& {
+ if (!this->has_value())
+ std::__throw_bad_optional_access();
+ return this->__get();
+ }
+
+ [[nodiscard]] constexpr _Tp& value() & {
+ if (!this->has_value())
+ std::__throw_bad_optional_access();
+ return this->__get();
+ }
+
+ [[nodiscard]] constexpr _Tp&& value() && {
+ if (!this->has_value())
+ std::__throw_bad_optional_access();
+ return std::move(this->__get());
+ }
+
+ [[nodiscard]] constexpr _Tp const&& value() const&& {
+ if (!this->has_value())
+ std::__throw_bad_optional_access();
+ return std::move(this->__get());
+ }
+};
+
+template <class _Tp>
+struct __optional_storage_base<_Tp, true> {
+ using value_type = _Tp;
+ using __raw_type _LIBCPP_NODEBUG = remove_reference_t<_Tp>;
+ __raw_type* __value_;
+
+ constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
+
+ template <class _Up>
+ constexpr void __convert_init_ref_val(_Up&& __val) noexcept {
+ _Tp& __r(std::forward<_Up>(__val));
+ __value_ = std::addressof(__r);
+ }
+
+ template <class _UArg>
+ constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) {
+ static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
+ "Attempted to construct a reference element in optional from a "
+ "possible temporary");
+ __convert_init_ref_val(std::forward<_UArg>(__uarg));
+ }
+
+# if _LIBCPP_STD_VER >= 23
+ template <class _Fp, class... _Args>
+ constexpr __optional_storage_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) {
+ _Tp& __r = std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...);
+ __value_ = std::addressof(__r);
+ }
+# endif
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
+
+ [[nodiscard]] constexpr bool has_value() const noexcept { return __value_ != nullptr; }
+
+ constexpr value_type& __get() const noexcept { return *__value_; }
+
+ template <class _UArg>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val) {
+ _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
+ static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
+ "Attempted to construct a reference element in tuple from a "
+ "possible temporary");
+ __convert_init_ref_val(std::forward<_UArg>(__val));
+ }
+
+ template <class _That>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
+ if (__opt.has_value())
+ __construct(std::forward<_That>(__opt).__get());
+ }
+
+ template <class _That>
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
+ if (has_value() == __opt.has_value()) {
+ if (has_value())
+ *__value_ = std::forward<_That>(__opt).__get();
+ } else {
+ if (has_value())
+ reset();
+ else
+ __construct(std::forward<_That>(__opt).__get());
+ }
+ }
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__optional_storage_base& __rhs) noexcept {
+ std::swap(__value_, __rhs.__value_);
+ }
+
+ // [optional.ref.observe]
+ constexpr add_pointer_t<_Tp> operator->() const noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+ return std::addressof(this->__get());
+ }
+
+ [[nodiscard]] constexpr _Tp& operator*() const noexcept {
+ _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+ return this->__get();
+ }
+
+ [[nodiscard]] constexpr _Tp& value() const {
+ if (!this->has_value())
+ std::__throw_bad_optional_access();
+ return this->__get();
+ }
+};
+
+template <class _Tp, bool = is_trivially_copy_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
+struct __optional_copy_base : __optional_storage_base<_Tp> {
+ using __optional_storage_base<_Tp>::__optional_storage_base;
+};
+
+template <class _Tp>
+struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> {
+ using __optional_storage_base<_Tp>::__optional_storage_base;
+
+ __optional_copy_base() = default;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_base(const __optional_copy_base& __opt) {
+ this->__construct_from(__opt);
+ }
+
+ __optional_copy_base(__optional_copy_base&&) = default;
+ __optional_copy_base& operator=(const __optional_copy_base&) = default;
+ __optional_copy_base& operator=(__optional_copy_base&&) = default;
+};
+
+template <class _Tp, bool = is_trivially_move_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
+struct __optional_move_base : __optional_copy_base<_Tp> {
+ using __optional_copy_base<_Tp>::__optional_copy_base;
+};
+
+template <class _Tp>
+struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> {
+ using value_type = _Tp;
+ using __optional_copy_base<_Tp>::__optional_copy_base;
+
+ __optional_move_base() = default;
+ __optional_move_base(const __optional_move_base&) = default;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20
+ __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v<value_type>) {
+ this->__construct_from(std::move(__opt));
+ }
+
+ __optional_move_base& operator=(const __optional_move_base&) = default;
+ __optional_move_base& operator=(__optional_move_base&&) = default;
+};
+
+template <class _Tp,
+ bool = (is_trivially_destructible_v<_Tp> && is_trivially_copy_constructible_v<_Tp> &&
+ is_trivially_copy_assignable_v<_Tp>) ||
+ is_lvalue_reference_v<_Tp>>
+struct __optional_copy_assign_base : __optional_move_base<_Tp> {
+ using __optional_move_base<_Tp>::__optional_move_base;
+};
+
+template <class _Tp>
+struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> {
+ using __optional_move_base<_Tp>::__optional_move_base;
+
+ __optional_copy_assign_base() = default;
+ __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
+ __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt) {
+ this->__assign_from(__opt);
+ return *this;
+ }
+
+ __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
+};
+
+template <class _Tp,
+ bool = (is_trivially_destructible_v<_Tp> && is_trivially_move_constructible_v<_Tp> &&
+ is_trivially_move_assignable_v<_Tp>) ||
+ is_lvalue_reference_v<_Tp>>
+struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> {
+ using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+};
+
+template <class _Tp>
+struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp> {
+ using value_type = _Tp;
+ using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+
+ __optional_move_assign_base() = default;
+ __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
+ __optional_move_assign_base(__optional_move_assign_base&&) = default;
+ __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
+
+ _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt) noexcept(
+ is_nothrow_move_assignable_v<value_type> && is_nothrow_move_constructible_v<value_type>) {
+ this->__assign_from(std::move(__opt));
+ return *this;
+ }
+};
+
+template <class _Tp>
+using __optional_sfinae_ctor_base_t _LIBCPP_NODEBUG =
+ __sfinae_ctor_base< is_copy_constructible<_Tp>::value, is_move_constructible<_Tp>::value >;
+
+template <class _Tp>
+using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
+ __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>),
+ (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>)>;
+
+template <class _Tp, class = void>
+struct __optional_iterator_base : __optional_move_assign_base<_Tp> {
+ using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
+};
+
+# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
+
+template <class _Tp>
+struct __optional_iterator_base<_Tp, enable_if_t<is_object_v<_Tp>>> : __optional_move_assign_base<_Tp> {
+private:
+ using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
+ using __const_pointer _LIBCPP_NODEBUG = add_pointer_t<const _Tp>;
+
+public:
+ using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
+
+# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+ using iterator = __bounded_iter<__pointer>;
+ using const_iterator = __bounded_iter<__const_pointer>;
+# else
+ using iterator = __capacity_aware_iterator<__pointer, optional<_Tp>, 1>;
+ using const_iterator = __capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>;
+# endif
+
+ // [optional.iterators], iterator support
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() noexcept {
+ auto* __ptr = std::addressof(this->__get());
+
+# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+ return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
+# else
+ return std::__make_capacity_aware_iterator<__pointer, optional<_Tp>, 1>(__ptr);
+# endif
+ }
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept {
+ auto* __ptr = std::addressof(this->__get());
+
+# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+ return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
+# else
+ return std::__make_capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>(__ptr);
+# endif
+ }
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() noexcept {
+ return begin() + (this->has_value() ? 1 : 0);
+ }
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
+ return begin() + (this->has_value() ? 1 : 0);
+ }
+};
+
+template <class _Tp>
+struct __optional_iterator_base<_Tp&, enable_if_t<is_object_v<_Tp> && !__is_unbounded_array_v<_Tp> >>
+ : __optional_move_assign_base<_Tp&> {
+private:
+ using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
+
+public:
+ using __optional_move_assign_base<_Tp&>::__optional_move_assign_base;
+
+# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+ using iterator = __bounded_iter<__pointer>;
+# else
+ using iterator = __capacity_aware_iterator<__pointer, optional<_Tp&>, 1>;
+# endif
+
+ // [optional.ref.iterators], iterator support
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const noexcept {
+ auto* __ptr = this->has_value() ? std::addressof(this->__get()) : nullptr;
+
+# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+ return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
+# else
+ return std::__make_capacity_aware_iterator<__pointer, optional<_Tp&>, 1>(__ptr);
+# endif
+ }
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const noexcept {
+ return begin() + (this->has_value() ? 1 : 0);
+ }
+};
+
+template <class _Tp>
+constexpr bool ranges::enable_view<optional<_Tp>> = true;
+
+template <class _Tp>
+constexpr range_format format_kind<optional<_Tp>> = range_format::disabled;
+
+template <class _Tp>
+constexpr bool ranges::enable_borrowed_range<optional<_Tp&>> = true;
+
+# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
+
+template <class _Tp, class... _Args>
+inline constexpr bool __is_constructible_for_optional_v = is_constructible_v<_Tp, _Args...>;
+
+template <class _Tp, class... _Args>
+struct __is_constructible_for_optional : bool_constant<__is_constructible_for_optional_v<_Tp, _Args...>> {};
+
+template <class _Tp, class _Up, class... _Args>
+inline constexpr bool __is_constructible_for_optional_initializer_list_v =
+ is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>;
+
+# if _LIBCPP_STD_VER >= 26
+template <class _Tp, class... _Args>
+inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Args...> = false;
+
+template <class _Tp, class _Arg>
+inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Arg> =
+ is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>;
+
+template <class _Tp, class _Up, class... _Args>
+inline constexpr bool __is_constructible_for_optional_initializer_list_v<_Tp&, _Up, _Args...> = false;
+# endif
+
+# if _LIBCPP_STD_VER >= 26
+template <class _Tp>
+static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp> || std::is_lvalue_reference_v<_Tp>;
+# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE "Result of f(value()) should be a valid contained type for optional"
+# else
+template <class _Tp>
+static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp>;
+# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE "Result of f(value()) should be an object type"
+# endif
+
+template <class _Tp>
+struct __is_std_optional : false_type {};
+
+template <class _Tp>
+struct __is_std_optional<optional<_Tp>> : true_type {};
+
+template <class _Tp>
+optional(_Tp) -> optional<_Tp>;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_OPTIONAL_COMMON_H
diff --git a/libcxx/include/__optional/comparison.h b/libcxx/include/__optional/comparison.h
new file mode 100644
index 0000000000000..db9d33b26ef89
--- /dev/null
+++ b/libcxx/include/__optional/comparison.h
@@ -0,0 +1,346 @@
+//===----------------------------------------------------------------------===//
+//
+// 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_OPTIONAL_COMPARISON_H
+#define _LIBCPP_OPTIONAL_COMPARISON_H
+
+#include <__compare/compare_three_way_result.h>
+#include <__compare/ordering.h>
+#include <__compare/three_way_comparable.h>
+#include <__config>
+#include <__fwd/optional.h>
+#include <__optional/nullopt_t.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_core_convertible.h>
+#include <__type_traits/is_swappable.h>
+#include <__utility/declval.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (static_cast<bool>(__x) != static_cast<bool>(__y))
+ return false;
+ if (!static_cast<bool>(__x))
+ return true;
+ return *__x == *__y;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (static_cast<bool>(__x) != static_cast<bool>(__y))
+ return true;
+ if (!static_cast<bool>(__x))
+ return false;
+ return *__x != *__y;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (!static_cast<bool>(__y))
+ return false;
+ if (!static_cast<bool>(__x))
+ return true;
+ return *__x < *__y;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (!static_cast<bool>(__x))
+ return false;
+ if (!static_cast<bool>(__y))
+ return true;
+ return *__x > *__y;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (!static_cast<bool>(__x))
+ return true;
+ if (!static_cast<bool>(__y))
+ return false;
+ return *__x <= *__y;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (!static_cast<bool>(__y))
+ return true;
+ if (!static_cast<bool>(__x))
+ return false;
+ return *__x >= *__y;
+}
+
+# if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, three_way_comparable_with<_Tp> _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
+operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) {
+ if (__x && __y)
+ return *__x <=> *__y;
+ return __x.has_value() <=> __y.has_value();
+}
+
+# endif // _LIBCPP_STD_VER >= 20
+
+// [optional.nullops] Comparison with nullopt
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, std::nullopt_t) noexcept {
+ return !static_cast<bool>(__x);
+}
+
+# if _LIBCPP_STD_VER <= 17
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept {
+ return !static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept {
+ return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept {
+ return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept {
+ return false;
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept {
+ return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept {
+ return !static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept {
+ return true;
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept {
+ return static_cast<bool>(__x);
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept {
+ return false;
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept {
+ return true;
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept {
+ return !static_cast<bool>(__x);
+}
+
+# else // _LIBCPP_STD_VER <= 17
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept {
+ return __x.has_value() <=> false;
+}
+
+# endif // _LIBCPP_STD_VER <= 17
+
+// [optional.comp.with.t] Comparison with T
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x == __v;
+ return false;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v == *__x;
+ return false;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x != __v;
+ return true;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v != *__x;
+ return true;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x < __v;
+ return true;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v < *__x;
+ return false;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x <= __v;
+ return true;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v <= *__x;
+ return false;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x > __v;
+ return false;
+}
+
+template < class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v > *__x;
+ return true;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const _Up& __v) {
+ if (__x.has_value())
+ return *__x >= __v;
+ return false;
+}
+
+template <
+ class _Tp,
+ class _Up,
+ enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+ int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __v, const optional<_Up>& __x) {
+ if (__x.has_value())
+ return __v >= *__x;
+ return true;
+}
+
+# if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+concept __is_derived_from_optional = requires(const _Tp& __t) { []<class _Up>(const optional<_Up>&) {}(__t); };
+
+template <class _Tp, class _Up>
+ requires(!__is_derived_from_optional<_Up>) && three_way_comparable_with<_Tp, _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
+operator<=>(const optional<_Tp>& __x, const _Up& __v) {
+ return __x.has_value() ? *__x <=> __v : strong_ordering::less;
+}
+
+# endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif
diff --git a/libcxx/include/__optional/hash.h b/libcxx/include/__optional/hash.h
new file mode 100644
index 0000000000000..830f99b0b855f
--- /dev/null
+++ b/libcxx/include/__optional/hash.h
@@ -0,0 +1,48 @@
+// -*- 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_OPTIONAL_HASH_H
+#define _LIBCPP_OPTIONAL_HASH_H
+
+#include <__config>
+#include <__cstddef/size_t.h>
+#include <__functional/hash.h>
+#include <__type_traits/remove_const.h>
+
+#include <__fwd/optional.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct hash< __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> > {
+# if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+ _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
+ _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
+# endif
+
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const optional<_Tp>& __opt) const {
+ return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+#endif // _LIBCPP_OPTIONAL_HASH_H
diff --git a/libcxx/include/__optional/nullopt_t.h b/libcxx/include/__optional/nullopt_t.h
new file mode 100644
index 0000000000000..bd66923f026b8
--- /dev/null
+++ b/libcxx/include/__optional/nullopt_t.h
@@ -0,0 +1,40 @@
+// -*- 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_OPTIONAL_NULLOPT_T_H
+#define _LIBCPP_OPTIONAL_NULLOPT_T_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct nullopt_t {
+ struct __secret_tag {
+ explicit __secret_tag() = default;
+ };
+ constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
+};
+
+inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+#endif
diff --git a/libcxx/include/__optional/optional.h b/libcxx/include/__optional/optional.h
new file mode 100644
index 0000000000000..f5f7047870713
--- /dev/null
+++ b/libcxx/include/__optional/optional.h
@@ -0,0 +1,411 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// std::optional<T>
+
+#ifndef _LIBCPP_OPTIONAL_OPTIONAL_H
+#define _LIBCPP_OPTIONAL_OPTIONAL_H
+
+#include <__concepts/invocable.h>
+#include <__config>
+#include <__functional/invoke.h>
+#include <__optional/common.h>
+#include <__optional/nullopt_t.h>
+#include <__tuple/sfinae_helpers.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/disjunction.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_destructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_scalar.h>
+#include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_relocatable.h>
+#include <__type_traits/negation.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+
+#include <initializer_list>
+
+#include <__optional/comparison.h>
+#include <__optional/hash.h>
+#include <__optional/swap.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _LIBCPP_DECLSPEC_EMPTY_BASES optional
+ : public __optional_iterator_base<_Tp>,
+ private __optional_sfinae_ctor_base_t<_Tp>,
+ private __optional_sfinae_assign_base_t<_Tp> {
+ using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp>;
+
+public:
+ using value_type = __libcpp_remove_reference_t<_Tp>;
+
+ using __trivially_relocatable _LIBCPP_NODEBUG =
+ conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
+
+private:
+ static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
+ static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
+# if _LIBCPP_STD_VER >= 26
+ static_assert(!is_rvalue_reference_v<_Tp>, "instantiation of optional with an rvalue reference type is ill-formed");
+# else
+ static_assert(!is_reference_v<_Tp>, "instantiation of optional with a reference type is ill-formed");
+# endif
+ static_assert(is_destructible_v<_Tp>, "instantiation of optional with a non-destructible type is ill-formed");
+ static_assert(!is_array_v<_Tp>, "instantiation of optional with an array type is ill-formed");
+
+ // LWG2756: conditionally explicit conversion from _Up
+ struct _CheckOptionalArgsConstructor {
+ template <class _Up>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
+ return is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>;
+ }
+
+ template <class _Up>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
+ return is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>;
+ }
+ };
+ template <class _Up>
+ using _CheckOptionalArgsCtor _LIBCPP_NODEBUG =
+ _If< _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value && _IsNotSame<__remove_cvref_t<_Up>, optional>::value &&
+ (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_optional<__remove_cvref_t<_Up>>::value),
+ _CheckOptionalArgsConstructor,
+ __check_tuple_constructor_fail >;
+ template <class _QualUp>
+ struct _CheckOptionalLikeConstructor {
+ template <class _Up, class _Opt = optional<_Up>>
+ using __check_constructible_from_opt _LIBCPP_NODEBUG =
+ _Or< is_constructible<_Tp, _Opt&>,
+ is_constructible<_Tp, _Opt const&>,
+ is_constructible<_Tp, _Opt&&>,
+ is_constructible<_Tp, _Opt const&&>,
+ is_convertible<_Opt&, _Tp>,
+ is_convertible<_Opt const&, _Tp>,
+ is_convertible<_Opt&&, _Tp>,
+ is_convertible<_Opt const&&, _Tp> >;
+ template <class _Up, class _Opt = optional<_Up>>
+ using __check_assignable_from_opt _LIBCPP_NODEBUG =
+ _Or< is_assignable<_Tp&, _Opt&>,
+ is_assignable<_Tp&, _Opt const&>,
+ is_assignable<_Tp&, _Opt&&>,
+ is_assignable<_Tp&, _Opt const&&> >;
+ template <class _Up, class _QUp = _QualUp>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
+ return is_convertible<_QUp, _Tp>::value &&
+ (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
+ }
+ template <class _Up, class _QUp = _QualUp>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
+ return !is_convertible<_QUp, _Tp>::value &&
+ (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
+ }
+ template <class _Up, class _QUp = _QualUp>
+ _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_assign() {
+ // Construction and assignability of _QUp to _Tp has already been
+ // checked.
+ return !__check_constructible_from_opt<_Up>::value && !__check_assignable_from_opt<_Up>::value;
+ }
+ };
+
+ template <class _Up, class _QualUp>
+ using _CheckOptionalLikeCtor _LIBCPP_NODEBUG =
+ _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp> >::value,
+ _CheckOptionalLikeConstructor<_QualUp>,
+ __check_tuple_constructor_fail >;
+ template <class _Up, class _QualUp>
+ using _CheckOptionalLikeAssign _LIBCPP_NODEBUG =
+ _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>, is_assignable<_Tp&, _QualUp> >::value,
+ _CheckOptionalLikeConstructor<_QualUp>,
+ __check_tuple_constructor_fail >;
+
+public:
+ _LIBCPP_HIDE_FROM_ABI constexpr optional() noexcept {}
+ _LIBCPP_HIDE_FROM_ABI constexpr optional(const optional&) = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr optional(optional&&) = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr optional(nullopt_t) noexcept {}
+
+ template <
+ class _InPlaceT,
+ class... _Args,
+ enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, __is_constructible_for_optional<_Tp, _Args...>>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_InPlaceT, _Args&&... __args)
+ : __base(in_place, std::forward<_Args>(__args)...) {}
+
+ template <class _Up,
+ class... _Args,
+ enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+ : __base(in_place, __il, std::forward<_Args>(__args)...) {}
+
+ template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
+
+ template <class _Up = remove_cv_t<_Tp>,
+ enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
+
+ // LWG2756: conditionally explicit conversion from const optional<_Up>&
+ template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
+ this->__construct_from(__v);
+ }
+
+ template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
+ this->__construct_from(__v);
+ }
+
+ // LWG2756: conditionally explicit conversion from optional<_Up>&&
+ template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
+ this->__construct_from(std::move(__v));
+ }
+
+ template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
+ this->__construct_from(std::move(__v));
+ }
+
+# if _LIBCPP_STD_VER >= 23
+ template <class _Tag,
+ class _Fp,
+ class... _Args,
+ enable_if_t<_IsSame<_Tag, __optional_construct_from_invoke_tag>::value, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
+ : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
+# endif
+
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept {
+ reset();
+ return *this;
+ }
+
+ _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(const optional&) = default;
+ _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&) = default;
+
+ // LWG2756
+ template <class _Up = remove_cv_t<_Tp>,
+ enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Up>, optional>,
+ _Or<_IsNotSame<__remove_cvref_t<_Up>, _Tp>, _Not<is_scalar<_Tp>>>,
+ is_constructible<_Tp, _Up>,
+ is_assignable<_Tp&, _Up>>::value,
+ int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
+ if (this->has_value())
+ this->__get() = std::forward<_Up>(__v);
+ else
+ this->__construct(std::forward<_Up>(__v));
+ return *this;
+ }
+
+ // LWG2756
+ template <class _Up, enable_if_t<_CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(const optional<_Up>& __v) {
+ this->__assign_from(__v);
+ return *this;
+ }
+
+ // LWG2756
+ template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_assign<_Up>(), int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(optional<_Up>&& __v) {
+ this->__assign_from(std::move(__v));
+ return *this;
+ }
+
+ template <class... _Args, enable_if_t<__is_constructible_for_optional_v<_Tp, _Args...>, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
+ reset();
+ this->__construct(std::forward<_Args>(__args)...);
+ return this->__get();
+ }
+
+ template <class _Up,
+ class... _Args,
+ enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+ reset();
+ this->__construct(__il, std::forward<_Args>(__args)...);
+ return this->__get();
+ }
+
+ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+ swap(optional& __opt) noexcept((is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)) {
+ this->__swap(__opt);
+ }
+
+ using __base::operator*;
+ using __base::operator->;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
+
+ using __base::__get;
+ using __base::has_value;
+ using __base::value;
+
+ template <class _Up = remove_cv_t<_Tp>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
+ static_assert(is_copy_constructible_v<_Tp>, "optional<T>::value_or: T must be copy constructible");
+ static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
+ return this->has_value() ? this->__get() : static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+ template <class _Up = remove_cv_t<_Tp>>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
+ static_assert(is_move_constructible_v<_Tp>, "optional<T>::value_or: T must be move constructible");
+ static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
+ return this->has_value() ? std::move(this->__get()) : static_cast<_Tp>(std::forward<_Up>(__v));
+ }
+
+# if _LIBCPP_STD_VER >= 23
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+ using _Up = invoke_result_t<_Func, _Tp&>;
+ static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+ "Result of f(value()) must be a specialization of std::optional");
+ if (*this)
+ return std::invoke(std::forward<_Func>(__f), value());
+ return remove_cvref_t<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+ using _Up = invoke_result_t<_Func, const _Tp&>;
+ static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+ "Result of f(value()) must be a specialization of std::optional");
+ if (*this)
+ return std::invoke(std::forward<_Func>(__f), value());
+ return remove_cvref_t<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+ using _Up = invoke_result_t<_Func, _Tp&&>;
+ static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+ "Result of f(std::move(value())) must be a specialization of std::optional");
+ if (*this)
+ return std::invoke(std::forward<_Func>(__f), std::move(value()));
+ return remove_cvref_t<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+ using _Up = invoke_result_t<_Func, const _Tp&&>;
+ static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+ "Result of f(std::move(value())) must be a specialization of std::optional");
+ if (*this)
+ return std::invoke(std::forward<_Func>(__f), std::move(value()));
+ return remove_cvref_t<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+ using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
+ static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
+ static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+ static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+ if (*this)
+ return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
+ return optional<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+ using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
+ static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
+ static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+ static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+ if (*this)
+ return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
+ return optional<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+ using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
+ static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
+ static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
+ static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+ if (*this)
+ return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+ return optional<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+ using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
+ static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
+ static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
+ static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+ if (*this)
+ return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+ return optional<_Up>();
+ }
+
+ template <invocable _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
+ requires is_copy_constructible_v<_Tp>
+ {
+ static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
+ "Result of f() should be the same type as this optional");
+ if (*this)
+ return *this;
+ return std::forward<_Func>(__f)();
+ }
+
+ template <invocable _Func>
+ [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
+ requires is_move_constructible_v<_Tp>
+ {
+ static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
+ "Result of f() should be the same type as this optional");
+ if (*this)
+ return std::move(*this);
+ return std::forward<_Func>(__f)();
+ }
+# endif // _LIBCPP_STD_VER >= 23
+
+ using __base::reset;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif
diff --git a/libcxx/include/__optional/optional_ref.h b/libcxx/include/__optional/optional_ref.h
new file mode 100644
index 0000000000000..fa763e4628f04
--- /dev/null
+++ b/libcxx/include/__optional/optional_ref.h
@@ -0,0 +1,218 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// std::optional<T&>
+
+#ifndef _LIBCPP_OPTIONAL_OPTIONAL_REF_H
+#define _LIBCPP_OPTIONAL_OPTIONAL_REF_H
+
+#include <__concepts/invocable.h>
+#include <__config>
+#include <__functional/invoke.h>
+#include <__fwd/optional.h>
+#include <__optional/common.h>
+#include <__optional/nullopt_t.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_trivially_relocatable.h>
+#include <__type_traits/reference_constructs_from_temporary.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 <__optional/comparison.h>
+#include <__optional/hash.h>
+#include <__optional/swap.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 26
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _LIBCPP_DECLSPEC_EMPTY_BASES optional<_Tp&> : public __optional_iterator_base<_Tp&> {
+ using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp&>;
+
+ template <class _Up, class _QualUp>
+ static constexpr bool __check_optionalU_ctor =
+ !std::is_same_v<std::remove_cv_t<_Tp>, optional<_Up>> && !std::is_same_v<_Tp&, _Up> &&
+ std::is_constructible_v<_Tp&, _QualUp>;
+
+ static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
+ static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
+
+public:
+ using value_type = _Tp;
+
+ constexpr optional() noexcept = default;
+ constexpr optional(nullopt_t) noexcept {}
+ constexpr optional(const optional&) noexcept = default;
+
+ template <class _Arg>
+ requires(std::is_constructible_v<_Tp&, _Arg> && !std::reference_constructs_from_temporary_v<_Tp&, _Arg>)
+ constexpr explicit optional(in_place_t, _Arg&& __arg) : __base(in_place, std::forward<_Arg>(__arg)) {}
+
+ template <class _Up>
+ requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
+ is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>) optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>)
+ : __base(in_place, std::forward<_Up>(__v)) {}
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
+ constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
+ optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) {
+ this->__construct_from(__rhs);
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
+ constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
+ optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) {
+ this->__construct_from(__rhs);
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
+ this->__construct_from(std::move(__rhs));
+ }
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
+ constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
+ optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) {
+ this->__construct_from(std::move(__rhs));
+ }
+
+ template <class _Tag, class _Fp, class... _Args>
+ requires(std::is_same_v<_Tag, __optional_construct_from_invoke_tag>)
+ _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
+ : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
+
+ // deleted overloads
+
+ template <class _Up>
+ requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
+ is_constructible_v<_Tp&, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up&> && std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
+ constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
+ optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up&> && std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
+ constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
+ optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr explicit(!is_convertible_v<_Up, _Tp&>)
+ optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) = delete;
+
+ template <class _Up>
+ requires(__check_optionalU_ctor<_Up, const _Up> && std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
+ constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
+ optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) = delete;
+
+ constexpr ~optional() = default;
+
+ using __base::__get;
+ using __base::reset;
+
+ _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(nullopt_t) noexcept {
+ reset();
+ return *this;
+ }
+
+ constexpr optional& operator=(const optional&) noexcept = default;
+
+ template <class _Up>
+ requires(is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
+ constexpr _Tp& emplace(_Up&& __u) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
+ this->__construct(std::forward<_Up>(__u));
+
+ return this->__get();
+ }
+
+ constexpr void swap(optional& __rhs) noexcept { this->__swap(__rhs); }
+
+ using __base::operator->;
+ using __base::operator*;
+ constexpr explicit operator bool() const noexcept { return has_value(); }
+ using __base::has_value;
+ using __base::value;
+
+ template <class _Up = remove_cv_t<_Tp>>
+ requires(is_object_v<_Tp> && !is_array_v<_Tp>)
+ [[nodiscard]] constexpr decay_t<_Tp> value_or(_Up&& __v) const {
+ using _XTp = remove_cv_t<_Tp>;
+ static_assert(is_constructible_v<_XTp, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
+ static_assert(is_convertible_v<_Up, _XTp>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
+ return this->has_value() ? this->__get() : static_cast<_XTp>(std::forward<_Up>(__v));
+ }
+
+ template <class _Func>
+ [[nodiscard]] constexpr auto and_then(_Func&& __f) const {
+ using _Up = invoke_result_t<_Func, _Tp&>;
+ static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+ "Result of f(value()) must be a specialization of std::optional");
+ if (*this)
+ return std::invoke(std::forward<_Func>(__f), value());
+ return remove_cvref_t<_Up>();
+ }
+
+ template <class _Func>
+ [[nodiscard]] constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>> transform(_Func&& __f) const {
+ using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
+ static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
+ static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+ static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
+ static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
+
+ if (*this)
+ return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
+ return optional<_Up>();
+ }
+
+ template <invocable _Func>
+ [[nodiscard]] constexpr optional or_else(_Func&& __f) const {
+ static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
+ "Result of f() should be the same type as this optional");
+ if (*this)
+ return *this;
+ return std::forward<_Func>(__f)();
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 26
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_OPTIONAL_OPTIONAL_REF_H
diff --git a/libcxx/include/__optional/swap.h b/libcxx/include/__optional/swap.h
new file mode 100644
index 0000000000000..39a58bb8eeb31
--- /dev/null
+++ b/libcxx/include/__optional/swap.h
@@ -0,0 +1,37 @@
+// -*- 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_OPTIONAL_SWAP_H
+#define _LIBCPP_OPTIONAL_SWAP_H
+
+#include <__config>
+#include <__fwd/optional.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_swappable.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
+ __x.swap(__y);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif
+
+#endif
diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in
index 5fa74b5b5db78..deee500f0dcbf 100644
--- a/libcxx/include/module.modulemap.in
+++ b/libcxx/include/module.modulemap.in
@@ -1795,6 +1795,25 @@ module std [system] {
}
module optional {
+ module fwd { header "__fwd/optional.h" }
+ module hash {
+ header "__optional/hash.h"
+ export std.functional.hash
+ }
+ module common {
+ header "__optional/common.h"
+ export std.iterator.bounded_iter
+ export std.iterator.capacity_aware_iterator
+ export std.format.fwd
+ export std.utility.swap
+ }
+
+ module comparison { header "__optional/comparison.h" }
+ module nullopt_t { header "__optional/nullopt_t.h" }
+ module optional { header "__optional/optional.h" }
+ module optional_ref { header "__optional/optional_ref.h" }
+ module swap { header "__optional/swap.h" }
+
header "optional"
export *
}
diff --git a/libcxx/include/optional b/libcxx/include/optional
index 424f5a5f58ca4..6975050a6e5ae 100644
--- a/libcxx/include/optional
+++ b/libcxx/include/optional
@@ -258,67 +258,33 @@ namespace std {
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
# include <__cxx03/__config>
#else
-# include <__assert>
-# include <__compare/compare_three_way_result.h>
-# include <__compare/ordering.h>
-# include <__compare/three_way_comparable.h>
-# include <__concepts/invocable.h>
# include <__config>
-# include <__exception/exception.h>
# include <__functional/hash.h>
-# include <__functional/invoke.h>
-# include <__functional/unary_function.h>
-# include <__fwd/format.h>
-# include <__fwd/functional.h>
-# include <__iterator/bounded_iter.h>
-# include <__iterator/capacity_aware_iterator.h>
-# include <__memory/addressof.h>
-# include <__memory/construct_at.h>
-# include <__ranges/enable_borrowed_range.h>
-# include <__ranges/enable_view.h>
-# include <__tuple/sfinae_helpers.h>
-# include <__type_traits/add_pointer.h>
-# include <__type_traits/conditional.h>
-# include <__type_traits/conjunction.h>
# include <__type_traits/decay.h>
-# include <__type_traits/disjunction.h>
# include <__type_traits/enable_if.h>
-# include <__type_traits/integral_constant.h>
-# include <__type_traits/invoke.h>
-# include <__type_traits/is_array.h>
-# include <__type_traits/is_assignable.h>
# include <__type_traits/is_constructible.h>
-# include <__type_traits/is_convertible.h>
-# include <__type_traits/is_core_convertible.h>
-# include <__type_traits/is_destructible.h>
-# include <__type_traits/is_function.h>
-# include <__type_traits/is_nothrow_assignable.h>
-# include <__type_traits/is_nothrow_constructible.h>
-# include <__type_traits/is_object.h>
-# include <__type_traits/is_reference.h>
-# include <__type_traits/is_same.h>
-# include <__type_traits/is_scalar.h>
-# include <__type_traits/is_swappable.h>
-# include <__type_traits/is_trivially_assignable.h>
-# include <__type_traits/is_trivially_constructible.h>
-# include <__type_traits/is_trivially_destructible.h>
-# include <__type_traits/is_trivially_relocatable.h>
-# include <__type_traits/negation.h>
-# include <__type_traits/reference_constructs_from_temporary.h>
# include <__type_traits/remove_const.h>
-# include <__type_traits/remove_cv.h>
-# include <__type_traits/remove_cvref.h>
-# include <__type_traits/remove_reference.h>
-# include <__utility/declval.h>
# include <__utility/forward.h>
# include <__utility/in_place.h>
-# include <__utility/move.h>
-# include <__utility/swap.h>
-# include <__verbose_abort>
# include <initializer_list>
# include <version>
-// standard-mandated includes
+# include <__optional/comparison.h>
+# include <__optional/swap.h>
+
+# include <__optional/common.h>
+# include <__optional/hash.h>
+# include <__optional/nullopt_t.h>
+# include <__optional/optional.h>
+# include <__optional/optional_ref.h>
+
+// TODO: Certain headers rely on these transitive includes.
+# include <__type_traits/conditional.h>
+# include <__type_traits/invoke.h>
+# include <__type_traits/is_object.h>
+# include <__type_traits/is_reference.h>
+# include <__type_traits/remove_cvref.h>
+# include <__utility/move.h>
// [optional.syn]
# include <compare>
@@ -330,1377 +296,13 @@ namespace std {
_LIBCPP_PUSH_MACROS
# include <__undef_macros>
-namespace std // purposefully not using versioning namespace
-{
-
-class _LIBCPP_EXPORTED_FROM_ABI bad_optional_access : public exception {
-public:
- _LIBCPP_HIDE_FROM_ABI bad_optional_access() _NOEXCEPT = default;
- _LIBCPP_HIDE_FROM_ABI bad_optional_access(const bad_optional_access&) _NOEXCEPT = default;
- _LIBCPP_HIDE_FROM_ABI bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
- // Get the key function ~bad_optional_access() into the dylib
- ~bad_optional_access() _NOEXCEPT override;
- [[__nodiscard__]] const char* what() const _NOEXCEPT override;
-};
-
-} // namespace std
-
# if _LIBCPP_STD_VER >= 17
_LIBCPP_BEGIN_NAMESPACE_STD
-[[noreturn]] inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_optional_access() {
-# if _LIBCPP_HAS_EXCEPTIONS
- throw bad_optional_access();
-# else
- _LIBCPP_VERBOSE_ABORT("bad_optional_access was thrown in -fno-exceptions mode");
-# endif
-}
-
-struct nullopt_t {
- struct __secret_tag {
- explicit __secret_tag() = default;
- };
- _LIBCPP_HIDE_FROM_ABI constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
-};
-
-inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
-
-struct __optional_construct_from_invoke_tag {};
-
-template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
-struct __optional_destruct_base;
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, false> {
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
- union {
- char __null_state_;
- remove_cv_t<value_type> __val_;
- };
- bool __engaged_;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__optional_destruct_base() {
- if (__engaged_)
- __val_.~value_type();
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(
- __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
- : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
- if (__engaged_) {
- __val_.~value_type();
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp>
-struct __optional_destruct_base<_Tp, true> {
- typedef _Tp value_type;
- static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
- union {
- char __null_state_;
- remove_cv_t<value_type> __val_;
- };
- bool __engaged_;
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
- : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(
- __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
- : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
- if (__engaged_) {
- __engaged_ = false;
- }
- }
-};
-
-template <class _Tp, bool = is_reference<_Tp>::value>
-struct __optional_storage_base : __optional_destruct_base<_Tp> {
- using __base _LIBCPP_NODEBUG = __optional_destruct_base<_Tp>;
- using value_type = _Tp;
- using __base::__base;
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__engaged_; }
-
- _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() & noexcept { return this->__val_; }
- _LIBCPP_HIDE_FROM_ABI constexpr const value_type& __get() const& noexcept { return this->__val_; }
- _LIBCPP_HIDE_FROM_ABI constexpr value_type&& __get() && noexcept { return std::move(this->__val_); }
- _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& __get() const&& noexcept { return std::move(this->__val_); }
-
- template <class... _Args>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args) {
- _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
- std::__construct_at(std::addressof(this->__val_), std::forward<_Args>(__args)...);
- this->__engaged_ = true;
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
- if (__opt.has_value())
- __construct(std::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
- if (this->__engaged_ == __opt.has_value()) {
- if (this->__engaged_)
- static_cast<_Tp&>(this->__val_) = std::forward<_That>(__opt).__get();
- } else {
- if (this->__engaged_)
- this->reset();
- else
- __construct(std::forward<_That>(__opt).__get());
- }
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
- __swap(__optional_storage_base& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) {
- using std::swap;
- if (this->has_value() == __rhs.has_value()) {
- if (this->has_value())
- swap(this->__get(), __rhs.__get());
- } else {
- if (this->has_value()) {
- __rhs.__construct(std::move(this->__get()));
- this->reset();
- } else {
- this->__construct(std::move(__rhs.__get()));
- __rhs.reset();
- }
- }
- }
-
- // [optional.observe]
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp const> operator->() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& value() const& {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return std::move(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const&& value() const&& {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return std::move(this->__get());
- }
-};
-
-template <class _Tp>
-struct __optional_storage_base<_Tp, true> {
- using value_type = _Tp;
- using __raw_type _LIBCPP_NODEBUG = remove_reference_t<_Tp>;
- __raw_type* __value_;
-
- _LIBCPP_HIDE_FROM_ABI constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
-
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI constexpr void __convert_init_ref_val(_Up&& __val) noexcept {
- _Tp& __r(std::forward<_Up>(__val));
- __value_ = std::addressof(__r);
- }
-
- template <class _UArg>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) {
- static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
- "Attempted to construct a reference element in optional from a "
- "possible temporary");
- __convert_init_ref_val(std::forward<_UArg>(__uarg));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Fp, class... _Args>
- constexpr __optional_storage_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args) {
- _Tp& __r = std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...);
- __value_ = std::addressof(__r);
- }
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
-
- _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() const noexcept { return *__value_; }
-
- template <class _UArg>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val) {
- _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
- static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
- "Attempted to construct a reference element in tuple from a "
- "possible temporary");
- __convert_init_ref_val(std::forward<_UArg>(__val));
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
- if (__opt.has_value())
- __construct(std::forward<_That>(__opt).__get());
- }
-
- template <class _That>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
- if (has_value() == __opt.has_value()) {
- if (has_value())
- *__value_ = std::forward<_That>(__opt).__get();
- } else {
- if (has_value())
- reset();
- else
- __construct(std::forward<_That>(__opt).__get());
- }
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__optional_storage_base& __rhs) noexcept {
- std::swap(__value_, __rhs.__value_);
- }
-
- // [optional.ref.observe]
- _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
- return std::addressof(this->__get());
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() const noexcept {
- _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
- return this->__get();
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() const {
- if (!this->has_value())
- std::__throw_bad_optional_access();
- return this->__get();
- }
-};
-
-template <class _Tp, bool = is_trivially_copy_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
-struct __optional_copy_base : __optional_storage_base<_Tp> {
- using __optional_storage_base<_Tp>::__optional_storage_base;
-};
-
-template <class _Tp>
-struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> {
- using __optional_storage_base<_Tp>::__optional_storage_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base() = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_base(const __optional_copy_base& __opt) {
- this->__construct_from(__opt);
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base(__optional_copy_base&&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(const __optional_copy_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(__optional_copy_base&&) = default;
-};
-
-template <class _Tp, bool = is_trivially_move_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
-struct __optional_move_base : __optional_copy_base<_Tp> {
- using __optional_copy_base<_Tp>::__optional_copy_base;
-};
-
-template <class _Tp>
-struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> {
- using value_type = _Tp;
- using __optional_copy_base<_Tp>::__optional_copy_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_base(const __optional_move_base&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
- __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v<value_type>) {
- this->__construct_from(std::move(__opt));
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(const __optional_move_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(__optional_move_base&&) = default;
-};
-
-template <class _Tp,
- bool = (is_trivially_destructible_v<_Tp> && is_trivially_copy_constructible_v<_Tp> &&
- is_trivially_copy_assignable_v<_Tp>) ||
- is_lvalue_reference_v<_Tp>>
-struct __optional_copy_assign_base : __optional_move_base<_Tp> {
- using __optional_move_base<_Tp>::__optional_move_base;
-};
-
-template <class _Tp>
-struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> {
- using __optional_move_base<_Tp>::__optional_move_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_assign_base&
- operator=(const __optional_copy_assign_base& __opt) {
- this->__assign_from(__opt);
- return *this;
- }
-
- _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
-};
-
-template <class _Tp,
- bool = (is_trivially_destructible_v<_Tp> && is_trivially_move_constructible_v<_Tp> &&
- is_trivially_move_assignable_v<_Tp>) ||
- is_lvalue_reference_v<_Tp>>
-struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> {
- using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-};
-
-template <class _Tp>
-struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp> {
- using value_type = _Tp;
- using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
-
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base() = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(__optional_move_assign_base&&) = default;
- _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_assign_base&
- operator=(__optional_move_assign_base&& __opt) noexcept(
- is_nothrow_move_assignable_v<value_type> && is_nothrow_move_constructible_v<value_type>) {
- this->__assign_from(std::move(__opt));
- return *this;
- }
-};
-
-template <class _Tp>
-using __optional_sfinae_ctor_base_t _LIBCPP_NODEBUG =
- __sfinae_ctor_base< is_copy_constructible<_Tp>::value, is_move_constructible<_Tp>::value >;
-
-template <class _Tp>
-using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
- __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>),
- (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>)>;
-
template <class _Tp>
class optional;
-# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-template <class _Tp>
-constexpr bool ranges::enable_view<optional<_Tp>> = true;
-
-template <class _Tp>
-constexpr range_format format_kind<optional<_Tp>> = range_format::disabled;
-
-template <class _Tp>
-constexpr bool ranges::enable_borrowed_range<optional<_Tp&>> = true;
-
-# endif
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp>
-concept __is_derived_from_optional = requires(const _Tp& __t) { []<class _Up>(const optional<_Up>&) {}(__t); };
-
-# endif // _LIBCPP_STD_VER >= 20
-
-template <class _Tp>
-struct __is_std_optional : false_type {};
-template <class _Tp>
-struct __is_std_optional<optional<_Tp>> : true_type {};
-
-template <class _Tp, class... _Args>
-inline constexpr bool __is_constructible_for_optional_v = is_constructible_v<_Tp, _Args...>;
-
-template <class _Tp, class... _Args>
-struct __is_constructible_for_optional : bool_constant<__is_constructible_for_optional_v<_Tp, _Args...>> {};
-
-template <class _Tp, class _Up, class... _Args>
-inline constexpr bool __is_constructible_for_optional_initializer_list_v =
- is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>;
-
-# if _LIBCPP_STD_VER >= 26
-template <class _Tp, class... _Args>
-inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Args...> = false;
-
-template <class _Tp, class _Arg>
-inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Arg> =
- is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>;
-
-template <class _Tp, class _Up, class... _Args>
-inline constexpr bool __is_constructible_for_optional_initializer_list_v<_Tp&, _Up, _Args...> = false;
-# endif
-
-# if _LIBCPP_STD_VER >= 26
-template <class _Tp>
-static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp> || std::is_lvalue_reference_v<_Tp>;
-# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE \
- "Result of f(value()) should be a valid contained type for optional"
-# else
-template <class _Tp>
-static constexpr bool __is_valid_optional_type = std::is_object_v<_Tp>;
-# define _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE "Result of f(value()) should be an object type"
-# endif
-
-template <class _Tp, class = void>
-struct __optional_iterator_base : __optional_move_assign_base<_Tp> {
- using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
-};
-
-# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-
-template <class _Tp>
-struct __optional_iterator_base<_Tp, enable_if_t<is_object_v<_Tp>>> : __optional_move_assign_base<_Tp> {
-private:
- using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
- using __const_pointer _LIBCPP_NODEBUG = add_pointer_t<const _Tp>;
-
-public:
- using __optional_move_assign_base<_Tp>::__optional_move_assign_base;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- using iterator = __bounded_iter<__pointer>;
- using const_iterator = __bounded_iter<__const_pointer>;
-# else
- using iterator = __capacity_aware_iterator<__pointer, optional<_Tp>, 1>;
- using const_iterator = __capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>;
-# endif
-
- // [optional.iterators], iterator support
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() noexcept {
- auto* __ptr = std::addressof(this->__get());
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__pointer, optional<_Tp>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept {
- auto* __ptr = std::addressof(this->__get());
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__const_pointer, optional<_Tp>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
-};
-
-template <class _Tp>
-struct __optional_iterator_base<_Tp&, enable_if_t<is_object_v<_Tp> && !__is_unbounded_array_v<_Tp> >>
- : __optional_move_assign_base<_Tp&> {
-private:
- using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
-
-public:
- using __optional_move_assign_base<_Tp&>::__optional_move_assign_base;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- using iterator = __bounded_iter<__pointer>;
-# else
- using iterator = __capacity_aware_iterator<__pointer, optional<_Tp&>, 1>;
-# endif
-
- // [optional.ref.iterators], iterator support
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const noexcept {
- auto* __ptr = this->has_value() ? std::addressof(this->__get()) : nullptr;
-
-# ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
- return std::__make_bounded_iter(__ptr, __ptr, __ptr + (this->has_value() ? 1 : 0));
-# else
- return std::__make_capacity_aware_iterator<__pointer, optional<_Tp&>, 1>(__ptr);
-# endif
- }
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const noexcept {
- return begin() + (this->has_value() ? 1 : 0);
- }
-};
-
-# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
-
-template <class _Tp>
-class _LIBCPP_DECLSPEC_EMPTY_BASES optional
- : public __optional_iterator_base<_Tp>,
- private __optional_sfinae_ctor_base_t<_Tp>,
- private __optional_sfinae_assign_base_t<_Tp> {
- using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp>;
-
-public:
- using value_type = __libcpp_remove_reference_t<_Tp>;
-
- using __trivially_relocatable _LIBCPP_NODEBUG =
- conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
-
-private:
- static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
-# if _LIBCPP_STD_VER >= 26
- static_assert(!is_rvalue_reference_v<_Tp>, "instantiation of optional with an rvalue reference type is ill-formed");
-# else
- static_assert(!is_reference_v<_Tp>, "instantiation of optional with a reference type is ill-formed");
-# endif
- static_assert(is_destructible_v<_Tp>, "instantiation of optional with a non-destructible type is ill-formed");
- static_assert(!is_array_v<_Tp>, "instantiation of optional with an array type is ill-formed");
-
- // LWG2756: conditionally explicit conversion from _Up
- struct _CheckOptionalArgsConstructor {
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
- return is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>;
- }
-
- template <class _Up>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
- return is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>;
- }
- };
- template <class _Up>
- using _CheckOptionalArgsCtor _LIBCPP_NODEBUG =
- _If< _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value && _IsNotSame<__remove_cvref_t<_Up>, optional>::value &&
- (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_optional<__remove_cvref_t<_Up>>::value),
- _CheckOptionalArgsConstructor,
- __check_tuple_constructor_fail >;
- template <class _QualUp>
- struct _CheckOptionalLikeConstructor {
- template <class _Up, class _Opt = optional<_Up>>
- using __check_constructible_from_opt _LIBCPP_NODEBUG =
- _Or< is_constructible<_Tp, _Opt&>,
- is_constructible<_Tp, _Opt const&>,
- is_constructible<_Tp, _Opt&&>,
- is_constructible<_Tp, _Opt const&&>,
- is_convertible<_Opt&, _Tp>,
- is_convertible<_Opt const&, _Tp>,
- is_convertible<_Opt&&, _Tp>,
- is_convertible<_Opt const&&, _Tp> >;
- template <class _Up, class _Opt = optional<_Up>>
- using __check_assignable_from_opt _LIBCPP_NODEBUG =
- _Or< is_assignable<_Tp&, _Opt&>,
- is_assignable<_Tp&, _Opt const&>,
- is_assignable<_Tp&, _Opt&&>,
- is_assignable<_Tp&, _Opt const&&> >;
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
- return is_convertible<_QUp, _Tp>::value &&
- (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
- }
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
- return !is_convertible<_QUp, _Tp>::value &&
- (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
- }
- template <class _Up, class _QUp = _QualUp>
- _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_assign() {
- // Construction and assignability of _QUp to _Tp has already been
- // checked.
- return !__check_constructible_from_opt<_Up>::value && !__check_assignable_from_opt<_Up>::value;
- }
- };
-
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeCtor _LIBCPP_NODEBUG =
- _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp> >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail >;
- template <class _Up, class _QualUp>
- using _CheckOptionalLikeAssign _LIBCPP_NODEBUG =
- _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>, is_assignable<_Tp&, _QualUp> >::value,
- _CheckOptionalLikeConstructor<_QualUp>,
- __check_tuple_constructor_fail >;
-
-public:
- _LIBCPP_HIDE_FROM_ABI constexpr optional() noexcept {}
- _LIBCPP_HIDE_FROM_ABI constexpr optional(const optional&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional(optional&&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional(nullopt_t) noexcept {}
-
- template <
- class _InPlaceT,
- class... _Args,
- enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, __is_constructible_for_optional<_Tp, _Args...>>::value, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_InPlaceT, _Args&&... __args)
- : __base(in_place, std::forward<_Args>(__args)...) {}
-
- template <class _Up,
- class... _Args,
- enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
- : __base(in_place, __il, std::forward<_Args>(__args)...) {}
-
- template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
-
- template <class _Up = remove_cv_t<_Tp>,
- enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
-
- // LWG2756: conditionally explicit conversion from const optional<_Up>&
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
- this->__construct_from(__v);
- }
-
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
- this->__construct_from(__v);
- }
-
- // LWG2756: conditionally explicit conversion from optional<_Up>&&
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
- this->__construct_from(std::move(__v));
- }
-
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
- this->__construct_from(std::move(__v));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Tag,
- class _Fp,
- class... _Args,
- enable_if_t<_IsSame<_Tag, __optional_construct_from_invoke_tag>::value, int> = 0>
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
- : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
-# endif
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept {
- reset();
- return *this;
- }
-
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(const optional&) = default;
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&) = default;
-
- // LWG2756
- template <class _Up = remove_cv_t<_Tp>,
- enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Up>, optional>,
- _Or<_IsNotSame<__remove_cvref_t<_Up>, _Tp>, _Not<is_scalar<_Tp>>>,
- is_constructible<_Tp, _Up>,
- is_assignable<_Tp&, _Up>>::value,
- int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
- if (this->has_value())
- this->__get() = std::forward<_Up>(__v);
- else
- this->__construct(std::forward<_Up>(__v));
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<_CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(const optional<_Up>& __v) {
- this->__assign_from(__v);
- return *this;
- }
-
- // LWG2756
- template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_assign<_Up>(), int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(optional<_Up>&& __v) {
- this->__assign_from(std::move(__v));
- return *this;
- }
-
- template <class... _Args, enable_if_t<__is_constructible_for_optional_v<_Tp, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
- reset();
- this->__construct(std::forward<_Args>(__args)...);
- return this->__get();
- }
-
- template <class _Up,
- class... _Args,
- enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
- reset();
- this->__construct(__il, std::forward<_Args>(__args)...);
- return this->__get();
- }
-
- _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
- swap(optional& __opt) noexcept((is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)) {
- this->__swap(__opt);
- }
-
- using __base::operator*;
- using __base::operator->;
-
- _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
-
- using __base::__get;
- using __base::has_value;
- using __base::value;
-
- template <class _Up = remove_cv_t<_Tp>>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
- static_assert(is_copy_constructible_v<_Tp>, "optional<T>::value_or: T must be copy constructible");
- static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? this->__get() : static_cast<_Tp>(std::forward<_Up>(__v));
- }
-
- template <class _Up = remove_cv_t<_Tp>>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
- static_assert(is_move_constructible_v<_Tp>, "optional<T>::value_or: T must be move constructible");
- static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
- return this->has_value() ? std::move(this->__get()) : static_cast<_Tp>(std::forward<_Up>(__v));
- }
-
-# if _LIBCPP_STD_VER >= 23
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
- using _Up = invoke_result_t<_Func, _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
- using _Up = invoke_result_t<_Func, const _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
- using _Up = invoke_result_t<_Func, _Tp&&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(std::move(value())) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), std::move(value()));
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
- using _Up = invoke_result_t<_Func, const _Tp&&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(std::move(value())) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), std::move(value()));
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
- using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
- static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
- return optional<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
- using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
- static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
- static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
- return optional<_Up>();
- }
-
- template <invocable _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
- requires is_copy_constructible_v<_Tp>
- {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return *this;
- return std::forward<_Func>(__f)();
- }
-
- template <invocable _Func>
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
- requires is_move_constructible_v<_Tp>
- {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return std::move(*this);
- return std::forward<_Func>(__f)();
- }
-# endif // _LIBCPP_STD_VER >= 23
-
- using __base::reset;
-};
-
-# if _LIBCPP_STD_VER >= 26
-template <class _Tp>
-class optional<_Tp&> : public __optional_iterator_base<_Tp&> {
- using __base _LIBCPP_NODEBUG = __optional_iterator_base<_Tp&>;
-
- template <class _Up, class _QualUp>
- static constexpr bool __check_optionalU_ctor =
- !std::is_same_v<std::remove_cv_t<_Tp>, optional<_Up>> && !std::is_same_v<_Tp&, _Up> &&
- std::is_constructible_v<_Tp&, _QualUp>;
- static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>, "instantiation of optional with in_place_t is ill-formed");
- static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
-
-public:
- using value_type = _Tp;
-
- constexpr optional() noexcept = default;
- constexpr optional(nullopt_t) noexcept {}
- constexpr optional(const optional&) noexcept = default;
-
- template <class _Arg>
- requires(std::is_constructible_v<_Tp&, _Arg> && !std::reference_constructs_from_temporary_v<_Tp&, _Arg>)
- constexpr explicit optional(in_place_t, _Arg&& __arg) : __base(in_place, std::forward<_Arg>(__arg)) {}
-
- template <class _Up>
- requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
- is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>) optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>)
- : __base(in_place, std::forward<_Up>(__v)) {}
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
- constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
- optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) {
- this->__construct_from(__rhs);
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up&> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
- constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
- optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) {
- this->__construct_from(__rhs);
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
- this->__construct_from(std::move(__rhs));
- }
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up> && !std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
- constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
- optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) {
- this->__construct_from(std::move(__rhs));
- }
-
- template <class _Tag, class _Fp, class... _Args>
- requires(std::is_same_v<_Tag, __optional_construct_from_invoke_tag>)
- _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Tag, _Fp&& __f, _Args&&... __args)
- : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
-
- // deleted overloads
-
- template <class _Up>
- requires(!std::is_same_v<std::remove_cvref_t<_Up>, optional> && !is_same_v<std::remove_cvref_t<_Up>, in_place_t> &&
- is_constructible_v<_Tp&, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(_Up&& __v) noexcept(is_nothrow_constructible_v<_Tp&, _Up>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up&> && std::reference_constructs_from_temporary_v<_Tp&, _Up&>)
- constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
- optional(optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up&>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up&> && std::reference_constructs_from_temporary_v<_Tp&, const _Up&>)
- constexpr explicit(!is_convertible_v<const _Up&, _Tp&>)
- optional(const optional<_Up>& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up&>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, _Up> && std::reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr explicit(!is_convertible_v<_Up, _Tp&>)
- optional(optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) = delete;
-
- template <class _Up>
- requires(__check_optionalU_ctor<_Up, const _Up> && std::reference_constructs_from_temporary_v<_Tp&, const _Up>)
- constexpr explicit(!is_convertible_v<const _Up, _Tp&>)
- optional(const optional<_Up>&& __rhs) noexcept(std::is_nothrow_constructible_v<_Tp&, const _Up>) = delete;
-
- constexpr ~optional() = default;
-
- using __base::__get;
-
- _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(nullopt_t) noexcept {
- reset();
- return *this;
- }
-
- constexpr optional& operator=(const optional&) noexcept = default;
-
- template <class _Up>
- requires(is_constructible_v<_Tp&, _Up> && !std::reference_constructs_from_temporary_v<_Tp&, _Up>)
- constexpr _Tp& emplace(_Up&& __u) noexcept(std::is_nothrow_constructible_v<_Tp&, _Up>) {
- this->__construct(std::forward<_Up>(__u));
-
- return this->__get();
- }
-
- constexpr void swap(optional& __rhs) noexcept { this->__swap(__rhs); }
-
- using __base::operator->;
- using __base::operator*;
- constexpr explicit operator bool() const noexcept { return has_value(); }
- using __base::has_value;
- using __base::value;
-
- template <class _Up = remove_cvref_t<_Tp>>
- requires(!std::is_array_v<_Tp> && std::is_object_v<_Tp>)
- [[nodiscard]] constexpr decay_t<_Tp> value_or(_Up&& __v) const {
- using _XTp = std::remove_cv_t<_Tp>;
- static_assert(std::is_constructible_v<_XTp, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
- static_assert(std::is_convertible_v<_Up, _XTp>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
- return this->has_value() ? this->__get() : static_cast<_XTp>(std::forward<_Up>(__v));
- }
-
- template <class _Func>
- [[nodiscard]] constexpr auto and_then(_Func&& __f) const {
- using _Up = invoke_result_t<_Func, _Tp&>;
- static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
- "Result of f(value()) must be a specialization of std::optional");
- if (*this)
- return std::invoke(std::forward<_Func>(__f), value());
- return remove_cvref_t<_Up>();
- }
-
- template <class _Func>
- [[nodiscard]] constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>> transform(_Func&& __f) const {
- using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
- static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
- static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
- static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
- static_assert(__is_valid_optional_type<_Up>, _LIBCPP_OPTIONAL_MONADIC_ASSERT_MESSAGE);
-
- if (*this)
- return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
- return optional<_Up>();
- }
-
- template <invocable _Func>
- [[nodiscard]] constexpr optional or_else(_Func&& __f) const {
- static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
- "Result of f() should be the same type as this optional");
- if (*this)
- return *this;
- return std::forward<_Func>(__f)();
- }
-
- using __base::reset;
-};
-# endif
-
-template <class _Tp>
-optional(_Tp) -> optional<_Tp>;
-
-// [optional.relops] Relational operators
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x == *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (static_cast<bool>(__x) != static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x != *__y;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__y))
- return false;
- if (!static_cast<bool>(__x))
- return true;
- return *__x < *__y;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__x))
- return false;
- if (!static_cast<bool>(__y))
- return true;
- return *__x > *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__x))
- return true;
- if (!static_cast<bool>(__y))
- return false;
- return *__x <= *__y;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (!static_cast<bool>(__y))
- return true;
- if (!static_cast<bool>(__x))
- return false;
- return *__x >= *__y;
-}
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp, three_way_comparable_with<_Tp> _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
-operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) {
- if (__x && __y)
- return *__x <=> *__y;
- return __x.has_value() <=> __y.has_value();
-}
-
-# endif // _LIBCPP_STD_VER >= 20
-
-// [optional.nullops] Comparison with nullopt
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, nullopt_t) noexcept {
- return !static_cast<bool>(__x);
-}
-
-# if _LIBCPP_STD_VER <= 17
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept {
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept {
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept {
- return !static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept {
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept {
- return static_cast<bool>(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept {
- return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept {
- return true;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept {
- return !static_cast<bool>(__x);
-}
-
-# else // _LIBCPP_STD_VER <= 17
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept {
- return __x.has_value() <=> false;
-}
-
-# endif // _LIBCPP_STD_VER <= 17
-
-// [optional.comp.with.t] Comparison with T
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x == __v;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v == *__x;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x != __v;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v != *__x;
- return true;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x < __v;
- return true;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v < *__x;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x <= __v;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v <= *__x;
- return false;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x > __v;
- return false;
-}
-
-template < class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v > *__x;
- return true;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const _Up& __v) {
- if (__x.has_value())
- return *__x >= __v;
- return false;
-}
-
-template <
- class _Tp,
- class _Up,
- enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
- int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __v, const optional<_Up>& __x) {
- if (__x.has_value())
- return __v >= *__x;
- return true;
-}
-
-# if _LIBCPP_STD_VER >= 20
-
-template <class _Tp, class _Up>
- requires(!__is_derived_from_optional<_Up>) && three_way_comparable_with<_Tp, _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
-operator<=>(const optional<_Tp>& __x, const _Up& __v) {
- return __x.has_value() ? *__x <=> __v : strong_ordering::less;
-}
-
-# endif // _LIBCPP_STD_VER >= 20
-
-template <class _Tp, enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
- __x.swap(__y);
-}
-
struct __make_optional_barrier_tag {
explicit __make_optional_barrier_tag() = default;
};
@@ -1729,18 +331,6 @@ make_optional(initializer_list<_Up> __il, _Args&&... __args) {
return optional<_Tp>(in_place, __il, std::forward<_Args>(__args)...);
}
-template <class _Tp>
-struct hash< __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> > {
-# if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
- _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
- _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
-# endif
-
- [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const optional<_Tp>& __opt) const {
- return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
- }
-};
-
_LIBCPP_END_NAMESPACE_STD
# endif // _LIBCPP_STD_VER >= 17
diff --git a/libcxx/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp b/libcxx/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
index 9cf3b08930121..606ee4002040b 100644
--- a/libcxx/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.bad_optional_access/derive.pass.cpp
@@ -12,6 +12,7 @@
// class bad_optional_access : public exception
+#include <exception>
#include <optional>
#include <type_traits>
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
index 00ca941668eb2..a13b4334da332 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
@@ -26,26 +26,26 @@ int main(int, char**) {
// clang-format off
{
#if TEST_STD_VER >= 26
- std::optional<int&&> opt2; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
+ std::optional<int&&> opt2; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
#else
- std::optional<char&> o1; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+ std::optional<char&> o1; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
#endif
- std::optional<NonDestructible> o2; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
- std::optional<char[20]> o3; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with an array type is ill-formed}}
+ std::optional<NonDestructible> o2; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+ std::optional<char[20]> o3; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with an array type is ill-formed}}
}
{
- std::optional< std::in_place_t> o1; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
- std::optional<const std::in_place_t> o2; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
- std::optional< volatile std::in_place_t> o3; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
- std::optional<const volatile std::in_place_t> o4; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+ std::optional< std::in_place_t> o1; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+ std::optional<const std::in_place_t> o2; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+ std::optional< volatile std::in_place_t> o3; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+ std::optional<const volatile std::in_place_t> o4; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
}
{
- std::optional< std::nullopt_t> o1; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
- std::optional<const std::nullopt_t> o2; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
- std::optional< volatile std::nullopt_t> o3; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
- std::optional<const volatile std::nullopt_t> o4; // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+ std::optional< std::nullopt_t> o1; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+ std::optional<const std::nullopt_t> o2; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+ std::optional< volatile std::nullopt_t> o3; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+ std::optional<const volatile std::nullopt_t> o4; // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
}
// clang-format on
return 0;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
index 7ab842bf68c51..28d3c61db4a9a 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
@@ -31,7 +31,7 @@ int main(int, char**) {
{
// optional(nullopt_t)
- std::optional opt(std::nullopt); // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+ std::optional opt(std::nullopt); // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
}
// clang-format on
return 0;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp b/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp
index a956ab3a219cf..cdf456c4154ff 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional_requires_destructible_object.verify.cpp
@@ -28,30 +28,30 @@ int main(int, char**)
using std::optional;
{
#if TEST_STD_VER >= 26
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
#else
- // expected-error-re at optional:* 2 {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+ // expected-error-re@*:* 2 {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
#endif
optional<int&> opt1;
optional<int&&> opt2;
}
{
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
- optional<X> opt3;
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+ optional<X> opt3;
}
{
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
- optional<void()> opt4;
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+ optional<void()> opt4;
}
{
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
- // expected-error-re at optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
- // expected-error at optional:* 1+ {{cannot form a reference to 'void'}}
- optional<const void> opt4;
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-object type is undefined behavior}}
+ // expected-error-re@*:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+ // expected-error@*:* 1+ {{cannot form a reference to 'void'}}
+ optional<const void> opt4;
}
// FIXME these are garbage diagnostics that Clang should not produce
- // expected-error at optional:* 0+ {{is not a base class}}
+ // expected-error@*:* 0+ {{is not a base class}}
- return 0;
+ return 0;
}
More information about the libcxx-commits
mailing list