diff --git a/libcxx/docs/FeatureTestMacroTable.rst b/libcxx/docs/FeatureTestMacroTable.rst
--- a/libcxx/docs/FeatureTestMacroTable.rst
+++ b/libcxx/docs/FeatureTestMacroTable.rst
@@ -312,6 +312,8 @@
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_typeinfo``                  *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_expected``                            ``202202L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_invoke_r``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_scoped_enum``                      ``202011L``
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -182,6 +182,9 @@
   __coroutine/noop_coroutine_handle.h
   __coroutine/trivial_awaitables.h
   __debug
+  __expected/bad_expected_access.h
+  __expected/expected.h
+  __expected/unexpected.h
   __errc
   __filesystem/copy_options.h
   __filesystem/directory_entry.h
@@ -480,6 +483,7 @@
   errno.h
   exception
   execution
+  expected
   experimental/__config
   experimental/__memory
   experimental/algorithm
diff --git a/libcxx/include/__expected/bad_expected_access.h b/libcxx/include/__expected/bad_expected_access.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__expected/bad_expected_access.h
@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+#define _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
+
+#include <__config>
+#include <__utility/move.h>
+#include <exception>
+
+#if _LIBCPP_STD_VER > 20 || _LIBCPP_BUILDING_LIBRARY
+
+namespace std {
+
+template <class>
+class bad_expected_access;
+
+template <>
+class _LIBCPP_EXCEPTION_ABI bad_expected_access<void> : public exception {
+protected:
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&) = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&) = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&) = default;
+  _LIBCPP_HIDE_FROM_ABI ~bad_expected_access() = default;
+public:
+  const char* what() const noexcept override;
+};
+
+template <class _Ep>
+class bad_expected_access : public bad_expected_access<void> {
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit bad_expected_access(_Ep __val) : __val_(std::move(__val)) {}
+
+  _LIBCPP_HIDE_FROM_ABI const char* what() const noexcept override {
+    return "bad_expected_access";
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Ep& error() & noexcept { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI const _Ep& error() const & noexcept { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI _Ep&& error() && noexcept { return std::move(__val_); }
+  _LIBCPP_HIDE_FROM_ABI const _Ep&& error() const && noexcept { return std::move(__val_); }
+private:
+  _Ep __val_;
+};
+} // namespace std
+
+#endif // _LIBCPP_STD_VER > 20
+
+#endif // _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
diff --git a/libcxx/include/__expected/expected.h b/libcxx/include/__expected/expected.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__expected/expected.h
@@ -0,0 +1,730 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___EXPECTED_EXPECTED_H
+#define _LIBCPP___EXPECTED_EXPECTED_H
+
+#include <__concepts/convertible_to.h>
+#include <__config>
+#include <__expected/bad_expected_access.h>
+#include <__expected/unexpected.h>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <initializer_list>
+#include <new>
+#include <type_traits>
+
+#if _LIBCPP_STD_VER > 20
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Type, class _Error>
+class expected {
+public:
+  using value_type = _Type;
+  using error_type = _Error;
+  using unexpected_type = unexpected<_Error>;
+
+  template <class>
+  static constexpr bool __is_unexpected = false;
+
+  template <class _Error2>
+  static constexpr bool __is_unexpected<unexpected<_Error2>> = true;
+
+  static_assert(!is_reference_v<value_type>, "The value type can't be a reference!");
+  static_assert(!is_reference_v<error_type>, "The error type can't be a reference!");
+  static_assert(!is_function_v<value_type>, "The value type can't be a function!");
+  static_assert(!is_function_v<error_type>, "The error type can't be a function!");
+  static_assert(!is_same_v<remove_cv<value_type>, in_place_t>, "The value type can't be in_place_t!");
+  static_assert(!is_same_v<remove_cv<error_type>, in_place_t>, "The error type can't be in_place_t!");
+  static_assert(!is_same_v<remove_cv<value_type>, unexpect_t>, "The value type can't be unexpect_t!");
+  static_assert(!is_same_v<remove_cv<error_type>, unexpect_t>, "The error type can't be unexpect_t!");
+  static_assert(!__is_unexpected<value_type>, "The value type can't be a specialization of unexpected!");
+  static_assert(is_same_v<remove_cv_t<_Type>, void> || is_destructible_v<_Type>,
+                "The value type has to be destructible!");
+  static_assert(is_destructible_v<_Error>, "The error type has to be destructible!");
+
+  template <class _Type2>
+  using rebind = expected<_Type2, error_type>;
+
+  // [expected.object.ctor]
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() requires is_default_constructible_v<value_type>
+      : __has_value_(true), __val_(value_type()) {}
+
+  constexpr explicit(false) expected(const expected&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false)
+  expected(const expected&) requires (is_trivially_copy_constructible_v<value_type>
+                                   && is_trivially_copy_constructible_v<error_type>) = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false)
+  expected(const expected& __rhs) requires (is_copy_constructible_v<value_type>
+                                         && is_copy_constructible_v<error_type>
+                                         && !(is_trivially_copy_constructible_v<value_type>
+                                           && is_trivially_copy_constructible_v<error_type>))
+      : __has_value_(__rhs.has_value()) {
+    if (has_value())
+      std::construct_at(std::addressof(__val_), __rhs.__val_);
+    else
+      std::construct_at(std::addressof(__unexpected_), __rhs.__unexpected_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false) expected(expected&&)
+      noexcept(is_nothrow_move_constructible_v<value_type> && is_nothrow_move_constructible_v<error_type>)
+      requires(is_trivially_move_constructible_v<value_type> && is_trivially_move_constructible_v<error_type>)
+      = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false) expected(expected&& __rhs)
+      noexcept(is_nothrow_move_constructible_v<value_type> && is_nothrow_move_constructible_v<error_type>)
+      requires(is_move_constructible_v<value_type> && is_move_constructible_v<error_type>
+            && !(is_trivially_move_constructible_v<value_type> && is_trivially_move_constructible_v<error_type>))
+      : __has_value_(__rhs.has_value()) {
+    if (has_value())
+      std::construct_at(std::addressof(__val_),std::move(__rhs.__val_));
+    else
+      std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+  }
+
+  template <class _Type2, class _Error2>
+  static constexpr bool __enable_other_expected_ctor =
+      !is_constructible_v<value_type, expected<_Type2, _Error2>&>
+   && !is_constructible_v<value_type, expected<_Type2, _Error2>>
+   && !is_constructible_v<value_type, const expected<_Type2, _Error2>&>
+   && !is_constructible_v<value_type, const expected<_Type2, _Error2>>
+   && !is_convertible_v<expected<_Type2, _Error2>&, _Type>
+   && !is_convertible_v<expected<_Type2, _Error2>&&, _Type>
+   && !is_convertible_v<const expected<_Type2, _Error2>&, _Type>
+   && !is_convertible_v<const expected<_Type2, _Error2>&&, _Type>
+   && !is_constructible_v<unexpected<error_type>, expected<_Type2, _Error2>&>
+   && !is_constructible_v<unexpected<error_type>, expected<_Type2, _Error2>>
+   && !is_constructible_v<unexpected<error_type>, const expected<_Type2, _Error2>&>
+   && !is_constructible_v<unexpected<error_type>, const expected<_Type2, _Error2>>;
+
+  template <class _Type2, class _Error2>
+      requires (__enable_other_expected_ctor<_Type2, _Error2>
+             && is_constructible_v<value_type, const _Type2&>
+             && is_constructible_v<error_type, const _Error2&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr
+    explicit(!is_convertible_v<const _Type2&, value_type> || !is_convertible_v<const _Error2&, error_type>)
+  expected(const expected<_Type2, _Error2>& __rhs) : __has_value_(__rhs.has_value()) {
+    if (has_value())
+      std::construct_at(std::addressof(__val_), __rhs.__val_);
+    else
+      std::construct_at(std::addressof(__unexpected_), __rhs.__unexpected_);
+  }
+
+  template <class _Type2, class _Error2>
+      requires (__enable_other_expected_ctor<_Type2, _Error2>
+             && is_constructible_v<value_type, _Type2>
+             && is_constructible_v<error_type, _Error2>)
+  _LIBCPP_HIDE_FROM_ABI constexpr
+    explicit(!is_convertible_v<_Type2, value_type> || !is_convertible_v<_Error2, error_type>)
+  expected(expected<_Type2, _Error2>&& __rhs)
+      : __has_value_(__rhs.has_value()) {
+    if (has_value())
+      std::construct_at(std::addressof(__val_), std::move(__rhs.__val_));
+    else
+      std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+  }
+
+  template <class _Type2 = value_type>
+    requires (!is_same_v<remove_cvref_t<_Type2>, in_place_t>
+           && !is_same_v<expected, remove_cvref_t<_Type2>>
+           && !__is_unexpected<_Type2>
+           && is_constructible_v<_Type2, value_type>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Type2, value_type>) expected(_Type2&& __val)
+      : __has_value_(true), __val_(std::forward<_Type2>(__val)) {}
+
+  template <class _Error2> requires (is_constructible_v<error_type, const _Error2&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Error2&, error_type>)
+  expected(const unexpected<_Error2>& __unexpected) : __has_value_(false), __unexpected_(__unexpected) {}
+
+  template <class _Error2> requires (is_constructible_v<error_type, _Error2>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Error2, error_type>)
+  expected(unexpected<_Error2>&& __unexpected) : __has_value_(false), __unexpected_(std::move(__unexpected)) {}
+
+  template <class... _Args> requires (is_constructible_v<value_type, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args)
+      : __has_value_(true), __val_(std::forward<_Args>(__args)...) {}
+
+  template <class _Type2, class... _Args> requires (is_constructible_v<value_type, initializer_list<_Type2>, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(in_place_t, initializer_list<_Type2> __il, _Args&&... __args)
+      : __has_value_(true), __val_(__il, std::forward<_Args>(__args)...) {}
+
+  template <class... _Args> requires (is_constructible_v<error_type, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
+      : __has_value_(false), __unexpected_(std::forward<_Args>(__args)...) {}
+
+  template <class _Type2, class... _Args> requires (is_constructible_v<error_type, initializer_list<_Type2>, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Type2> __il, _Args&&... __args)
+      : __has_value_(false), __unexpected_(__il, std::forward<_Args>(__args)...) {}
+
+  // [expected.object.dtor]
+  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+      requires (is_trivially_destructible_v<value_type> && is_trivially_destructible_v<error_type>) = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
+      requires (!is_trivially_destructible_v<value_type> || !is_trivially_destructible_v<error_type>) {
+    if (has_value())
+      std::destroy_at(std::addressof(__val_));
+    else
+      std::destroy_at(std::addressof(__unexpected_));
+  }
+
+  // [expected.object.assign]
+
+private:
+  template <class _Type1, class _Type2, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(_Type1& __newval, _Type2& __oldval, _Args&&... __args) {
+    if constexpr (is_nothrow_constructible_v<_Type1, _Args...>) {
+      std::destroy_at(std::addressof(__oldval));
+      std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+    } else if constexpr (is_nothrow_move_constructible_v<_Type1>) {
+      _Type1 __tmp(std::forward<_Args>(__args)...);
+      std::destroy_at(std::addressof(__oldval));
+      std::construct_at(std::addressof(__newval), std::move(__tmp));
+    } else {
+      _Type2 __tmp(std::move(__oldval));
+      std::destroy_at(addressof(__oldval));
+      try {
+        std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+      } catch(...) {
+        std::construct_at(std::addressof(__oldval), std::move(__tmp));
+        throw;
+      }
+    }
+  }
+
+public:
+
+  constexpr expected& operator=(const expected&) = delete;
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
+    requires (is_copy_assignable_v<value_type>
+           && is_copy_constructible_v<value_type>
+           && is_copy_assignable_v<error_type>
+           && is_copy_constructible_v<error_type>
+           && (is_nothrow_move_constructible_v<value_type> || is_nothrow_move_constructible_v<error_type>)) {
+    if (__rhs.has_value() && has_value())
+      __val_ = *__rhs;
+    else if (has_value())
+      __reinit_expected(__unexpected_, __val_, __rhs.error());
+    else if (__rhs.has_value())
+      __reinit_expected(__val_, __unexpected_, *__rhs);
+    else
+      __unexpected_ = __rhs.error();
+    __has_value_ = __rhs.has_value();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
+      noexcept(is_nothrow_move_assignable_v<value_type> && is_nothrow_move_constructible_v<value_type> &&
+               is_nothrow_move_assignable_v<error_type> && is_nothrow_move_constructible_v<error_type>)
+      requires(is_move_constructible_v<value_type>
+            && is_move_assignable_v<value_type>
+            && is_move_constructible_v<error_type>
+            && is_move_assignable_v<error_type>
+            && (is_nothrow_move_constructible_v<value_type> || is_nothrow_move_constructible_v<error_type>)) {
+    if (has_value() && __rhs.has_value())
+      __val_ = std::move(*__rhs);
+    else if (has_value())
+      __reinit_expected(__unexpected_, __val_, std::move(__rhs.error()));
+    else if (__rhs.has_value())
+      __reinit_expected(__val_, __unexpected_, std::move(*__rhs));
+    else
+      __unexpected_ = std::move(__rhs.error());
+    __has_value_ = __rhs.has_value();
+    return *this;
+  }
+
+  template <class _Type2 = value_type> requires (!is_same_v<expected, remove_cvref_t<_Type2>>
+                                              && !__is_unexpected<remove_cvref_t<_Type2>>
+                                              && is_constructible_v<value_type, _Type2>
+                                              && is_assignable_v<value_type&, _Type2>
+                                              && (is_nothrow_constructible_v<value_type, _Type2>
+                                               || is_nothrow_move_constructible_v<value_type>
+                                               || is_nothrow_move_constructible_v<error_type>))
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Type2&& __val) {
+    if (has_value()) {
+      __val_ = std::forward<_Type2>(__val);
+    } else {
+      __reinit_expected(__val_, __unexpected_, std::forward<_Type2>(__val));
+      __has_value_ = true;
+    }
+    return *this;
+  }
+
+  template <class _QualifiedError>
+  static constexpr bool __enable_unexpected_ctor = is_constructible_v<error_type, _QualifiedError>
+                                                && is_assignable_v<error_type&, _QualifiedError>
+                                                && (is_nothrow_constructible_v<error_type, _QualifiedError>
+                                                 || is_nothrow_move_constructible_v<value_type>
+                                                 || is_nothrow_move_constructible_v<error_type>);
+
+  template <class _Error2> requires (__enable_unexpected_ctor<const _Error2&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_Error2>& __rhs) {
+    if (has_value())
+      __reinit_expected(__unexpected_, __val_, __rhs);
+    else
+      __unexpected_ = __rhs.error();
+  }
+
+  template <class _Error2> requires (__enable_unexpected_ctor<_Error2>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_Error2>&& __rhs) {
+    if (has_value())
+      __reinit_expected(__unexpected_, __val_, std::move(__rhs));
+    else
+      __unexpected_ = std::move(__rhs.error());
+  }
+
+  template <class... _Args> requires(is_nothrow_constructible_v<value_type, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& emplace(_Args&&... __args) noexcept {
+    if (has_value()) {
+      std::destroy_at(std::addressof(__val_));
+    } else {
+      std::destroy_at(std::addressof(__unexpected_));
+      __has_value_ = true;
+    }
+    return *std::construct_at(std::addressof(__val_), std::forward<_Args>(__args)...);
+  }
+
+  template <class _Type2, class... _Args>
+    requires(is_nothrow_constructible_v<value_type, initializer_list<_Type2>, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& emplace(initializer_list<_Type2> __il, _Args&&... __args) noexcept {
+    if (has_value()) {
+      std::destroy_at(std::addressof(__val_));
+    } else {
+      std::destroy_at(std::addressof(__unexpected_));
+      __has_value_ = true;
+    }
+    return *std::construct_at(std::addressof(__val_), __il, std::forward<_Args>(__args)...);
+  }
+
+  // [expected.object.swap]
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs) noexcept(false)
+    requires(is_swappable_v<value_type>
+          && is_swappable_v<error_type>
+          && is_move_constructible_v<value_type>
+          && is_move_constructible_v<error_type>
+          && (is_nothrow_move_constructible_v<value_type> || is_nothrow_move_constructible_v<error_type>)) {
+    if (has_value()) {
+      if (__rhs.has_value()) {
+        using std::swap;
+        swap(__val_, __rhs.__val_);
+      } else {
+        __rhs.swap(*this);
+      }
+    } else {
+      if (__rhs.has_value()) {
+        if constexpr (is_nothrow_move_constructible_v<error_type>) {
+          error_type __tmp(std::move(__rhs.__unexpected_));
+          std::destroy_at(std::addressof(__rhs.__unexpected_));
+          try {
+            std::construct_at(std::addressof(__rhs.__val_), std::move(__val_));
+            std::destroy_at(std::addressof(__val_));
+            std::construct_at(std::addressof(__unexpected_), std::move(__tmp));
+          } catch (...) {
+            std::construct_at(std::addressof(__rhs.__unexpected_), std::move(__tmp));
+            throw;
+          }
+        } else {
+          value_type __tmp(std::move(__val_));
+          std::destroy_at(std::addressof(__val_));
+          try {
+            std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+            std::destroy_at(std::addressof(__rhs.__unexpected_));
+            std::construct_at(std::addressof(__rhs.__val_), std::move(__tmp));
+          } catch (...) {
+            std::construct_at(std::addressof(__val_), std::move(__tmp));
+            throw;
+          }
+        }
+      } else {
+        using std::swap;
+        swap(__unexpected_, __rhs.__unexpected_);
+      }
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __lhs, expected& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs))) {
+    __lhs.swap(__rhs);
+  }
+
+  // [expected.object.obs]
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type* operator->() const noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return std::addressof(__val_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type* operator->() noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return std::addressof(__val_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type& operator*() const & noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return __val_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& operator*() & noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return __val_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& operator*() const && noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return std::move(__val_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& operator*() && noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+    return std::move(__val_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type& value() const & {
+    if (has_value())
+      return __val_;
+    throw bad_expected_access(error());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& value() & {
+    if (has_value())
+      return __val_;
+    throw bad_expected_access(error());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& value() const && {
+    if (has_value())
+      return std::move(__val_);
+    throw bad_expected_access(error());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& value() && {
+    if (has_value())
+      return std::move(__val_);
+    throw bad_expected_access(error());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const error_type& error() const & {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return __unexpected_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr error_type& error() & {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return __unexpected_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const error_type&& error() const && {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return std::move(__unexpected_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr error_type&& error() && {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return std::move(__unexpected_);
+  }
+
+  template <class _Type2>
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Type2&& __val) const & {
+    static_assert(is_copy_constructible_v<value_type>, "value_type has to be copy constructible");
+    static_assert(is_convertible_v<_Type2, value_type>, "argument has to be convertible to value_type");
+    return has_value() ? **this : static_cast<value_type>(std::forward<_Type2>(__val));
+  }
+
+  template <class _Type2>
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Type2&& __val) && {
+    static_assert(is_copy_constructible_v<value_type>, "value_type has to be copy constructible");
+    static_assert(is_convertible_v<_Type2, value_type>, "argument has to be convertible to value_type");
+    return has_value() ? std::move(**this) : static_cast<value_type>(std::forward<_Type2>(__val));
+  }
+
+  // [expected.object.eq]
+  template <class _Type2, class _Error2> requires (!is_void_v<_Type2>)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr
+  bool operator==(const expected& __lhs, const expected<_Type2, _Error2>& __rhs) {
+    static_assert(requires { *__lhs == *__rhs -> convertible_to<bool>; },
+                  "TODO: find a good error message");
+    static_assert(requires { __lhs.error() == __rhs.error() -> convertible_to<bool>; },
+                  "TODO: find a good error message");
+    if (__lhs.has_value() != __rhs.has_value())
+      return false;
+    if (__lhs.has_value())
+      return *__lhs == *__rhs;
+    return __lhs.error() == __rhs.error();
+  }
+
+  template <class _Type2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr
+  bool operator==(const expected& __lhs, const _Type2& __rhs) {
+    static_assert(requires { *__lhs == __rhs -> convertible_to<bool>; }, "TODO: find a good error message");
+    return __lhs.has_value() && static_cast<bool>(*__lhs == __rhs);
+  }
+
+  template <class _Error2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr
+  bool operator==(const expected& __lhs, const unexpected<_Error2> __rhs) {
+    static_assert(requires { __lhs.error() == __rhs.value() -> convertible_to<bool>; },
+                  "TODO: find a good error message");
+    return !__lhs.has_value() && static_cast<bool>(__lhs.error() == __rhs.value());
+  }
+
+private:
+  bool __has_value_;
+  union {
+    value_type __val_;
+    error_type __unexpected_;
+  };
+
+  template <class, class>
+  friend class expected;
+};
+
+template <class _Type, class _Error> requires is_void_v<_Type>
+class expected<_Type, _Error> {
+public:
+  using value_type = _Type;
+  using error_type = _Error;
+  using unexpected_type = unexpected<_Error>;
+
+  template <class _Type2>
+  using rebind = expected<_Type2, error_type>;
+
+  // [expected.void.ctor]
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __has_value_(true) {}
+
+  constexpr expected(const expected&) = delete;
+  constexpr expected(const expected&) requires is_trivially_copy_constructible_v<error_type> = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false) expected(const expected& __rhs)
+      requires is_copy_constructible_v<error_type> {
+    if (__rhs.has_value())
+      std::construct_at(std::addressof(__unexpected_), __rhs.__unexpected_);
+    __has_value_ = __rhs.has_value();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&) requires is_trivially_move_constructible_v<error_type> = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(false) expected(expected&& __rhs) noexcept(false)
+      requires is_move_constructible_v<error_type> {
+    if (!__rhs.has_value())
+      std::construct_at(std::addressof(__rhs.__unexpected_), std::move(__rhs.__unexpected_));
+    __has_value_ = __rhs.has_value();
+  }
+
+  template <class _Type2, class _Error2>
+  static constexpr bool __enable_other_expected_ctor =
+      is_void_v<_Type2>
+   && !is_constructible_v<unexpected<error_type>, expected<_Type2, _Error2>&>
+   && !is_constructible_v<unexpected<error_type>, expected<_Type2, _Error2>>
+   && !is_constructible_v<unexpected<error_type>, const expected<_Type2, _Error2>>
+   && !is_constructible_v<unexpected<error_type>, const expected<_Type2, _Error2>>;
+
+  template <class _Type2, class _Error2>
+      requires (__enable_other_expected_ctor<_Type2, _Error2> && is_constructible_v<error_type, const _Error2&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Error2&, error_type>)
+  expected(const expected<_Type2, _Error2>& __rhs) {
+    if (!__rhs.has_value())
+      std::construct_at(std::addressof(__unexpected_), __rhs.__unexpected_);
+    __has_value_ = __rhs.has_value();
+  }
+
+  template <class _Type2, class _Error2>
+      requires (__enable_other_expected_ctor<_Type2, _Error2> && is_constructible_v<error_type, _Error2>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Type2, _Error2>)
+  expected(expected<_Type2, _Error2>&& __rhs) {
+    if (!__rhs.has_value())
+      std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+    __has_value_ = __rhs.has_value();
+  }
+
+  template <class _Error2> requires is_constructible_v<error_type, const _Error2&>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Error2&, error_type>)
+  expected(const unexpected<_Error2>& __err) : __has_value_(false), __unexpected_(__err) {}
+
+  template <class _Error2> requires is_constructible_v<error_type, _Error2>
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(unexpected<_Error2>&& __err)
+      : __has_value_(false), __unexpected_(std::move(__err)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __has_value_(true) {}
+
+  template <class... _Args> requires is_constructible_v<error_type, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
+      : __has_value_(false), __unexpected_(std::forward<_Args>(__args)...) {}
+
+  template <class _Type2, class... _Args> requires is_constructible_v<error_type, initializer_list<_Type2>, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Type2> __il, _Args&&... __args)
+      : __has_value_(false), __unexpected_(__il, std::forward<_Args>(__args)...) {}
+
+  // [expected.void.dtor]
+  _LIBCPP_HIDE_FROM_ABI ~expected() requires is_trivially_destructible_v<error_type> = default;
+
+  _LIBCPP_HIDE_FROM_ABI ~expected() {
+    if (!has_value())
+      std::destroy_at(std::addressof(__unexpected_));
+  }
+
+  // [expected.void.assign]
+  _LIBCPP_HIDE_FROM_ABI  expected& operator=(const expected& __rhs) {
+    if (has_value() && __rhs.has_value())
+      return;
+    if (has_value()) {
+      std::construct_at(std::addressof(__unexpected_), __rhs.__unexpected_);
+    } else if (__rhs.has_value()) {
+      std::destroy_at(std::addressof(__unexpected_));
+      __has_value_ = true;
+    } else {
+      __unexpected_ = __rhs.error();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
+      noexcept(is_nothrow_move_constructible_v<error_type> && is_nothrow_move_assignable_v<error_type>) {
+    if (has_value() && __rhs.has_value())
+      return;
+    if (has_value()) {
+      std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+      __has_value_ = false;
+    } else if (__rhs.has_value()) {
+      std::destroy_at(std::addressof(__unexpected_));
+      __has_value_ = true;
+    } else {
+      __unexpected_ = __rhs.error();
+    }
+  }
+
+  template <class _Error2>
+      requires (is_constructible_v<error_type, const _Error2&> && is_assignable_v<error_type&, const _Error2&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_Error2>& __err) {
+    if (has_value()) {
+      std::construct_at(std::addressof(__unexpected_), __err.value());
+      __has_value_ = false;
+    } else {
+      __unexpected_ = __err.value();
+    }
+    return *this;
+  }
+
+  template <class _Error2> requires (is_constructible_v<error_type, _Error2> && is_assignable_v<error_type&, _Error2>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_Error2>&& __err) {
+    if (has_value()) {
+      std::construct_at(std::addressof(__unexpected_), std::move(__err.value()));
+      __has_value_ = false;
+    } else {
+      __unexpected_ = std::move(__err.value());
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept {
+    if (!has_value()) {
+      std::destroy_at(std::addressof(__unexpected_));
+      __has_value_ = true;
+    }
+  }
+
+  // [expected.void.swap]
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
+      noexcept(is_nothrow_move_constructible_v<error_type> && is_nothrow_swappable_v<error_type>)
+      requires(is_swappable_v<error_type> && is_move_constructible_v<error_type>) {
+    if (has_value()) {
+      if (!__rhs.has_value()) {
+        std::construct_at(std::addressof(__unexpected_), std::move(__rhs.__unexpected_));
+        std::destroy_at(std::addressof(__rhs.__unexpected_));
+        __has_value_ = false;
+        __rhs.__has_value_ = true;
+      }
+    } else {
+      if (__rhs.has_value()) {
+        __rhs.swap(*this);
+      } else {
+        using std::swap;
+        swap(__unexpected_, __rhs.__unexpected_);
+      }
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __lhs, expected& __rhs)
+      noexcept(noexcept(__lhs.swap(__rhs))) {
+    __lhs.swap(__rhs);
+  }
+
+  // [expected.void.obs]
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept {
+    _LIBCPP_ASSERT(has_value(), "Trying to access value of expected which contains an error.");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void value() const & {
+    if (!has_value())
+      throw bad_expected_access(error());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void value() && {
+    if (!has_value())
+      throw bad_expected_access(std::move(error()));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const error_type& error() const & {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return __unexpected_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr error_type& error() & {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return __unexpected_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const error_type&& error() const && {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return std::move(__unexpected_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr error_type&& error() && {
+    _LIBCPP_ASSERT(has_value(), "Trying to access error of expected which contains a value.");
+    return std::move(__unexpected_);
+  }
+
+  // [expected.void.eq]
+  template <class _Type2, class _Error2> requires is_void_v<_Type2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr
+  bool operator==(const expected& __lhs, const expected<_Type2, _Error2>& __rhs) {
+    static_assert(requires { __lhs.error() == __rhs.error() -> convertible_to<bool>; },
+                  "TODO: find good error message");
+    if (__lhs.has_value() != __rhs.has_value())
+      return false;
+    return __lhs.has_value() || static_cast<bool>(__lhs.error() == __rhs.error());
+  }
+
+  template <class _Error2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __lhs, const unexpected<_Error2>& __rhs) {
+    static_assert(requires { __lhs.error() == __rhs.value() -> convertible_to<bool>; },
+                  "TODO: find good error message");
+    return !__lhs.has_value() && static_cast<bool>(__lhs.error() == __rhs.value());
+  }
+
+private:
+  bool __has_value_;
+  union {
+    error_type __unexpected_;
+  };
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 20
+
+#endif // _LIBCPP___EXPECTED_EXPECTED_H
diff --git a/libcxx/include/__expected/unexpected.h b/libcxx/include/__expected/unexpected.h
new file mode 100644
--- /dev/null
+++ b/libcxx/include/__expected/unexpected.h
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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___UNEXPECTED_H
+#define _LIBCPP___UNEXPECTED_H
+
+#include <__config>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+#include <initializer_list>
+#include <type_traits>
+
+#if _LIBCPP_STD_VER > 20
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Ep>
+class unexpected {
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected(const unexpected&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected(unexpected&&) = default;
+
+  template <class... _Args>
+    requires(is_constructible_v<_Ep, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, _Args&&... __args)
+      : __val(std::forward<_Args>(__args)...) {}
+
+  template <class _Up, class... _Args>
+    requires(is_constructible_v<_Ep, initializer_list<_Up>, _Args...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+      : __val(__il, std::forward<_Args>(__args)...) {}
+
+  template <class _Err = _Ep>
+    requires(!is_same_v<remove_cvref_t<_Err>, unexpected> && !is_same_v<remove_cvref_t<_Err>, in_place_t> &&
+             is_constructible_v<_Ep, _Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit unexpected(_Err&& __e) : __val(std::forward<_Err>(__e)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Ep& value() const& noexcept { return __val; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ep& value() & noexcept { return __val; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Ep&& value() const&& noexcept { return std::move(__val); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ep&& value() && noexcept { return std::move(__val); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Ep>) {
+    static_assert(is_swappable_v<_Ep>, "E has to be swappable");
+
+    using std::swap;
+    swap(__val, __other.__val);
+  }
+
+  template <class _E2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const unexpected& __lhs, const unexpected<_E2>& __rhs) {
+    return __lhs.value() == __rhs.value();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr
+  void swap(unexpected& __lhs, unexpected& __rhs) noexcept(noexcept(__lhs.swap(__rhs)))
+      requires is_swappable_v<_Ep> {
+    __lhs.swap(__rhs);
+  }
+
+private:
+  _Ep __val;
+};
+
+template <class _Ep> unexpected(_Ep) -> unexpected<_Ep>;
+
+struct unexpect_t {
+  explicit unexpect_t() = default;
+};
+inline constexpr unexpect_t unexpect{};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 20
+
+#endif // _LIBCPP___UNEXPECTED_H
diff --git a/libcxx/include/expected b/libcxx/include/expected
new file mode 100644
--- /dev/null
+++ b/libcxx/include/expected
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+/*
+namespace std {
+  // [expected.un.object], class template unexpected
+  template<class E> class unexpected;
+
+  // [expected.bad], class template bad_­expected_­access
+  template<class E> class bad_expected_access;
+
+  // [expected.bad.void], specialization for void
+  template<> class bad_expected_access<void>;
+
+  // in-place construction of unexpected values
+  struct unexpect_t {
+    explicit unexpect_t() = default;
+  };
+  inline constexpr unexpect_t unexpect{};
+
+  // [expected.expected], class template expected
+  template<class T, class E> class expected;
+
+  // [expected.void], partial specialization of expected for void types
+  template<class T, class E> requires is_void_v<T> class expected<T, E>;
+}
+*/
+
+#ifndef _LIBCPP_EXPECTED
+#define _LIBCPP_EXPECTED
+
+#include <__config>
+#include <__expected/bad_expected_access.h>
+#include <__expected/expected.h>
+#include <__expected/unexpected.h>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#endif // _LIBCPP_EXPECTED
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -499,6 +499,16 @@
     header "execution"
     export *
   }
+  module expected {
+    header "expected"
+    export *
+
+    module __expected {
+      module bad_expected_access { private header "__expected/bad_expected_access.h" }
+      module expected            { private header "__expected/expected.h" }
+      module unexcpected         { private header "__expected/unexpected.h" }
+    }
+  }
   module filesystem {
     header "filesystem"
     export *
diff --git a/libcxx/include/version b/libcxx/include/version
--- a/libcxx/include/version
+++ b/libcxx/include/version
@@ -79,6 +79,7 @@
 __cpp_lib_exchange_function                             201304L <utility>
 __cpp_lib_execution                                     201902L <execution>
                                                         201603L // C++17
+__cpp_lib_expected                                      202202L <expected>
 __cpp_lib_filesystem                                    201703L <filesystem>
 __cpp_lib_format                                        202106L <format>
 __cpp_lib_gcd_lcm                                       201606L <numeric>
@@ -380,6 +381,7 @@
 # define __cpp_lib_byteswap                             202110L
 // # define __cpp_lib_constexpr_cmath                      202202L
 // # define __cpp_lib_constexpr_typeinfo                   202106L
+# define __cpp_lib_expected                             202202L
 // # define __cpp_lib_invoke_r                             202106L
 # define __cpp_lib_is_scoped_enum                       202011L
 # define __cpp_lib_monadic_optional                     202110L
diff --git a/libcxx/src/CMakeLists.txt b/libcxx/src/CMakeLists.txt
--- a/libcxx/src/CMakeLists.txt
+++ b/libcxx/src/CMakeLists.txt
@@ -7,6 +7,7 @@
   assert.cpp
   atomic.cpp
   barrier.cpp
+  bad_expected_access.cpp
   bind.cpp
   charconv.cpp
   chrono.cpp
diff --git a/libcxx/src/bad_expected_access.cpp b/libcxx/src/bad_expected_access.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/src/bad_expected_access.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <expected>
+
+namespace std {
+const char* bad_expected_access<void>::what() const noexcept {
+  return "bad_expected_access<void>";
+}
+} // namespace std
diff --git a/libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.cpp b/libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.cpp
--- a/libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.cpp
+++ b/libcxx/test/libcxx/assertions/headers_declare_assertion_handler.sh.cpp
@@ -310,458 +310,464 @@
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_47
-#if defined(TEST_47) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-#   include <filesystem>
+// RUN: %{build} -DTEST_46
+#if defined(TEST_46)
+#   include <expected>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_49
-#if defined(TEST_49)
-#   include <format>
+// RUN: %{build} -DTEST_48
+#if defined(TEST_48) && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
+#   include <filesystem>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_50
 #if defined(TEST_50)
-#   include <forward_list>
+#   include <format>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_51
-#if defined(TEST_51) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <fstream>
+#if defined(TEST_51)
+#   include <forward_list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_52
-#if defined(TEST_52)
-#   include <functional>
+#if defined(TEST_52) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <fstream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_53
-#if defined(TEST_53) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <future>
+#if defined(TEST_53)
+#   include <functional>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_54
-#if defined(TEST_54)
-#   include <initializer_list>
+#if defined(TEST_54) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <future>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_56
-#if defined(TEST_56) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <iomanip>
+// RUN: %{build} -DTEST_55
+#if defined(TEST_55)
+#   include <initializer_list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_57
 #if defined(TEST_57) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <ios>
+#   include <iomanip>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_58
-#if defined(TEST_58)
-#   include <iosfwd>
+#if defined(TEST_58) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <ios>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_59
-#if defined(TEST_59) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <iostream>
+#if defined(TEST_59)
+#   include <iosfwd>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_60
 #if defined(TEST_60) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <istream>
+#   include <iostream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_61
-#if defined(TEST_61)
-#   include <iterator>
+#if defined(TEST_61) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <istream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_62
-#if defined(TEST_62) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <latch>
+#if defined(TEST_62)
+#   include <iterator>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_63
-#if defined(TEST_63)
-#   include <limits>
+#if defined(TEST_63) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <latch>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_65
-#if defined(TEST_65)
-#   include <list>
+// RUN: %{build} -DTEST_64
+#if defined(TEST_64)
+#   include <limits>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_66
-#if defined(TEST_66) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <locale>
+#if defined(TEST_66)
+#   include <list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_68
-#if defined(TEST_68)
-#   include <map>
+// RUN: %{build} -DTEST_67
+#if defined(TEST_67) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <locale>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_70
-#if defined(TEST_70)
-#   include <memory>
+// RUN: %{build} -DTEST_69
+#if defined(TEST_69)
+#   include <map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_71
-#if defined(TEST_71) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <mutex>
+#if defined(TEST_71)
+#   include <memory>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_72
-#if defined(TEST_72)
-#   include <new>
+#if defined(TEST_72) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <mutex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_73
 #if defined(TEST_73)
-#   include <numbers>
+#   include <new>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_74
 #if defined(TEST_74)
-#   include <numeric>
+#   include <numbers>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_75
 #if defined(TEST_75)
-#   include <optional>
+#   include <numeric>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_76
-#if defined(TEST_76) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <ostream>
+#if defined(TEST_76)
+#   include <optional>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_77
-#if defined(TEST_77)
-#   include <queue>
+#if defined(TEST_77) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <ostream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_78
 #if defined(TEST_78)
-#   include <random>
+#   include <queue>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_79
 #if defined(TEST_79)
-#   include <ranges>
+#   include <random>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_80
 #if defined(TEST_80)
-#   include <ratio>
+#   include <ranges>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_81
-#if defined(TEST_81) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <regex>
+#if defined(TEST_81)
+#   include <ratio>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_82
-#if defined(TEST_82)
-#   include <scoped_allocator>
+#if defined(TEST_82) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   include <regex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_83
-#if defined(TEST_83) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <semaphore>
+#if defined(TEST_83)
+#   include <scoped_allocator>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_84
-#if defined(TEST_84)
+#if defined(TEST_84) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <semaphore>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_85
+#if defined(TEST_85)
 #   include <set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_86
-#if defined(TEST_86) && !defined(_LIBCPP_HAS_NO_THREADS)
+// RUN: %{build} -DTEST_87
+#if defined(TEST_87) && !defined(_LIBCPP_HAS_NO_THREADS)
 #   include <shared_mutex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_87
-#if defined(TEST_87)
+// RUN: %{build} -DTEST_88
+#if defined(TEST_88)
 #   include <span>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_88
-#if defined(TEST_88) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+// RUN: %{build} -DTEST_89
+#if defined(TEST_89) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <sstream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_89
-#if defined(TEST_89)
+// RUN: %{build} -DTEST_90
+#if defined(TEST_90)
 #   include <stack>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_92
-#if defined(TEST_92)
+// RUN: %{build} -DTEST_93
+#if defined(TEST_93)
 #   include <stdexcept>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_96
-#if defined(TEST_96) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+// RUN: %{build} -DTEST_97
+#if defined(TEST_97) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_97
-#if defined(TEST_97)
+// RUN: %{build} -DTEST_98
+#if defined(TEST_98)
 #   include <string>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_99
-#if defined(TEST_99)
+// RUN: %{build} -DTEST_100
+#if defined(TEST_100)
 #   include <string_view>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_100
-#if defined(TEST_100) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+// RUN: %{build} -DTEST_101
+#if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <strstream>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_101
-#if defined(TEST_101)
+// RUN: %{build} -DTEST_102
+#if defined(TEST_102)
 #   include <system_error>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_103
-#if defined(TEST_103) && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <thread>
-    using HandlerType = decltype(std::__libcpp_assertion_handler);
-#endif
-
 // RUN: %{build} -DTEST_104
-#if defined(TEST_104)
-#   include <tuple>
+#if defined(TEST_104) && !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <thread>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_105
 #if defined(TEST_105)
-#   include <type_traits>
+#   include <tuple>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_106
 #if defined(TEST_106)
-#   include <typeindex>
+#   include <type_traits>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_107
 #if defined(TEST_107)
-#   include <typeinfo>
+#   include <typeindex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_109
-#if defined(TEST_109)
-#   include <unordered_map>
+// RUN: %{build} -DTEST_108
+#if defined(TEST_108)
+#   include <typeinfo>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_110
 #if defined(TEST_110)
-#   include <unordered_set>
+#   include <unordered_map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_111
 #if defined(TEST_111)
-#   include <utility>
+#   include <unordered_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_112
 #if defined(TEST_112)
-#   include <valarray>
+#   include <utility>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_113
 #if defined(TEST_113)
-#   include <variant>
+#   include <valarray>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_114
 #if defined(TEST_114)
-#   include <vector>
+#   include <variant>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_115
 #if defined(TEST_115)
-#   include <version>
+#   include <vector>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
-// RUN: %{build} -DTEST_118
-#if defined(TEST_118)
-#   include <experimental/algorithm>
+// RUN: %{build} -DTEST_116
+#if defined(TEST_116)
+#   include <version>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_119
-#if defined(TEST_119) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
+#if defined(TEST_119)
+#   include <experimental/algorithm>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_120
-#if defined(TEST_120) && __cplusplus >= 201103L
-#   include <experimental/deque>
+#if defined(TEST_120) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
+#   include <experimental/coroutine>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_121
 #if defined(TEST_121) && __cplusplus >= 201103L
-#   include <experimental/forward_list>
+#   include <experimental/deque>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_122
-#if defined(TEST_122)
-#   include <experimental/functional>
+#if defined(TEST_122) && __cplusplus >= 201103L
+#   include <experimental/forward_list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_123
 #if defined(TEST_123)
-#   include <experimental/iterator>
+#   include <experimental/functional>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_124
-#if defined(TEST_124) && __cplusplus >= 201103L
-#   include <experimental/list>
+#if defined(TEST_124)
+#   include <experimental/iterator>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_125
 #if defined(TEST_125) && __cplusplus >= 201103L
-#   include <experimental/map>
+#   include <experimental/list>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_126
 #if defined(TEST_126) && __cplusplus >= 201103L
-#   include <experimental/memory_resource>
+#   include <experimental/map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_127
-#if defined(TEST_127)
-#   include <experimental/propagate_const>
+#if defined(TEST_127) && __cplusplus >= 201103L
+#   include <experimental/memory_resource>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_128
-#if defined(TEST_128) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#   include <experimental/regex>
+#if defined(TEST_128)
+#   include <experimental/propagate_const>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_129
-#if defined(TEST_129) && __cplusplus >= 201103L
-#   include <experimental/set>
+#if defined(TEST_129) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#   include <experimental/regex>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_130
-#if defined(TEST_130)
-#   include <experimental/simd>
+#if defined(TEST_130) && __cplusplus >= 201103L
+#   include <experimental/set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_131
-#if defined(TEST_131) && __cplusplus >= 201103L
-#   include <experimental/string>
+#if defined(TEST_131)
+#   include <experimental/simd>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_132
-#if defined(TEST_132)
-#   include <experimental/type_traits>
+#if defined(TEST_132) && __cplusplus >= 201103L
+#   include <experimental/string>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_133
-#if defined(TEST_133) && __cplusplus >= 201103L
-#   include <experimental/unordered_map>
+#if defined(TEST_133)
+#   include <experimental/type_traits>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_134
 #if defined(TEST_134) && __cplusplus >= 201103L
-#   include <experimental/unordered_set>
+#   include <experimental/unordered_map>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_135
-#if defined(TEST_135)
-#   include <experimental/utility>
+#if defined(TEST_135) && __cplusplus >= 201103L
+#   include <experimental/unordered_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_136
-#if defined(TEST_136) && __cplusplus >= 201103L
-#   include <experimental/vector>
+#if defined(TEST_136)
+#   include <experimental/utility>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_137
-#if defined(TEST_137)
-#   include <ext/hash_map>
+#if defined(TEST_137) && __cplusplus >= 201103L
+#   include <experimental/vector>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
 
 // RUN: %{build} -DTEST_138
 #if defined(TEST_138)
+#   include <ext/hash_map>
+    using HandlerType = decltype(std::__libcpp_assertion_handler);
+#endif
+
+// RUN: %{build} -DTEST_139
+#if defined(TEST_139)
 #   include <ext/hash_set>
     using HandlerType = decltype(std::__libcpp_assertion_handler);
 #endif
diff --git a/libcxx/test/libcxx/clang_tidy.sh.cpp b/libcxx/test/libcxx/clang_tidy.sh.cpp
--- a/libcxx/test/libcxx/clang_tidy.sh.cpp
+++ b/libcxx/test/libcxx/clang_tidy.sh.cpp
@@ -90,6 +90,7 @@
 #include <errno.h>
 #include <exception>
 #include <execution>
+#include <expected>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
diff --git a/libcxx/test/libcxx/double_include.sh.cpp b/libcxx/test/libcxx/double_include.sh.cpp
--- a/libcxx/test/libcxx/double_include.sh.cpp
+++ b/libcxx/test/libcxx/double_include.sh.cpp
@@ -93,6 +93,7 @@
 #include <errno.h>
 #include <exception>
 #include <execution>
+#include <expected>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
diff --git a/libcxx/test/libcxx/min_max_macros.compile.pass.cpp b/libcxx/test/libcxx/min_max_macros.compile.pass.cpp
--- a/libcxx/test/libcxx/min_max_macros.compile.pass.cpp
+++ b/libcxx/test/libcxx/min_max_macros.compile.pass.cpp
@@ -139,6 +139,8 @@
 TEST_MACROS();
 #include <execution>
 TEST_MACROS();
+#include <expected>
+TEST_MACROS();
 #include <fenv.h>
 TEST_MACROS();
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
diff --git a/libcxx/test/libcxx/nasty_macros.compile.pass.cpp b/libcxx/test/libcxx/nasty_macros.compile.pass.cpp
--- a/libcxx/test/libcxx/nasty_macros.compile.pass.cpp
+++ b/libcxx/test/libcxx/nasty_macros.compile.pass.cpp
@@ -203,6 +203,7 @@
 #include <errno.h>
 #include <exception>
 #include <execution>
+#include <expected>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
diff --git a/libcxx/test/libcxx/no_assert_include.compile.pass.cpp b/libcxx/test/libcxx/no_assert_include.compile.pass.cpp
--- a/libcxx/test/libcxx/no_assert_include.compile.pass.cpp
+++ b/libcxx/test/libcxx/no_assert_include.compile.pass.cpp
@@ -90,6 +90,7 @@
 #include <errno.h>
 #include <exception>
 #include <execution>
+#include <expected>
 #include <fenv.h>
 #if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
 #   include <filesystem>
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -215,6 +215,9 @@
 #include <__coroutine/noop_coroutine_handle.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/noop_coroutine_handle.h'}}
 #include <__coroutine/trivial_awaitables.h> // expected-error@*:* {{use of private header from outside its module: '__coroutine/trivial_awaitables.h'}}
 #include <__errc> // expected-error@*:* {{use of private header from outside its module: '__errc'}}
+#include <__expected/bad_expected_access.h> // expected-error@*:* {{use of private header from outside its module: '__expected/bad_expected_access.h'}}
+#include <__expected/expected.h> // expected-error@*:* {{use of private header from outside its module: '__expected/expected.h'}}
+#include <__expected/unexpected.h> // expected-error@*:* {{use of private header from outside its module: '__expected/unexpected.h'}}
 #include <__filesystem/copy_options.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/copy_options.h'}}
 #include <__filesystem/directory_entry.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_entry.h'}}
 #include <__filesystem/directory_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__filesystem/directory_iterator.h'}}
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/expected.version.pass.cpp
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// <expected>
+
+// Test the feature test macros defined by <expected>
+
+/*  Constant              Value
+    __cpp_lib_expected    202202L [C++2b]
+*/
+
+#include <expected>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
+#elif TEST_STD_VER > 20
+
+# ifndef __cpp_lib_expected
+#   error "__cpp_lib_expected should be defined in c++2b"
+# endif
+# if __cpp_lib_expected != 202202L
+#   error "__cpp_lib_expected should have the value 202202L in c++2b"
+# endif
+
+#endif // TEST_STD_VER > 20
+
+int main(int, char**) { return 0; }
diff --git a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp
@@ -73,6 +73,7 @@
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]
                                                    201902L [C++20]
+    __cpp_lib_expected                             202202L [C++2b]
     __cpp_lib_filesystem                           201703L [C++17]
     __cpp_lib_format                               202106L [C++20]
     __cpp_lib_gcd_lcm                              201606L [C++17]
@@ -404,6 +405,10 @@
 #   error "__cpp_lib_execution should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_filesystem
 #   error "__cpp_lib_filesystem should not be defined before c++17"
 # endif
@@ -1039,6 +1044,10 @@
 #   error "__cpp_lib_execution should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
 # ifdef __cpp_lib_filesystem
 #   error "__cpp_lib_filesystem should not be defined before c++17"
 # endif
@@ -1785,6 +1794,10 @@
 #   endif
 # endif
 
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   ifndef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should be defined in c++17"
@@ -2834,6 +2847,10 @@
 #   endif
 # endif
 
+# ifdef __cpp_lib_expected
+#   error "__cpp_lib_expected should not be defined before c++2b"
+# endif
+
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   ifndef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should be defined in c++20"
@@ -4087,6 +4104,13 @@
 #   endif
 # endif
 
+# ifndef __cpp_lib_expected
+#   error "__cpp_lib_expected should be defined in c++2b"
+# endif
+# if __cpp_lib_expected != 202202L
+#   error "__cpp_lib_expected should have the value 202202L in c++2b"
+# endif
+
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   ifndef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should be defined in c++2b"
diff --git a/libcxx/test/std/utilities/expected/expected.bad/ctor.pass.cpp b/libcxx/test/std/utilities/expected/expected.bad/ctor.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.bad/ctor.pass.cpp
@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <exception>
+#include <expected>
+#include <type_traits>
+
+struct S {};
+static_assert(std::is_base_of_v<std::bad_expected_access<void>, std::bad_expected_access<S>>);
+static_assert(std::is_base_of_v<std::exception, std::bad_expected_access<void>>);
+
+int main(int, char**) {
+  std::bad_expected_access<int> e(1);
+  assert(e.error() == 1);
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.bad/error.pass.cpp b/libcxx/test/std/utilities/expected/expected.bad/error.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.bad/error.pass.cpp
@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <ranges>
+#include <utility>
+
+int main(int, char**) {
+  {
+    std::bad_expected_access<int> e(1);
+    std::same_as<int&> decltype(auto) v = e.error();
+    assert(v == 1);
+  }
+
+  {
+    const std::bad_expected_access<int> e(1);
+    std::same_as<const int&> decltype(auto) v = e.error();
+    assert(v == 1);
+  }
+
+  {
+    std::bad_expected_access<int> e(1);
+    std::same_as<int&&> decltype(auto) v = std::move(e).error();
+    assert(v == 1);
+  }
+
+  {
+    const std::bad_expected_access<int> e(1);
+    std::same_as<const int&&> decltype(auto) v = std::move(e).error();
+    assert(v == 1);
+  }
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.bad/what.pass.cpp b/libcxx/test/std/utilities/expected/expected.bad/what.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.bad/what.pass.cpp
@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <expected>
+#include <ranges>
+
+int main(int, char**) {
+  {
+    std::bad_expected_access<int> e(1);
+    std::same_as<const char*> decltype(auto) what = e.what();
+    while (*what != '\0')
+      ++what;
+  }
+  {
+    std::bad_expected_access<int> e_(1);
+    std::bad_expected_access<void>& e = e_;
+    std::same_as<const char*> decltype(auto) what = e.what();
+    while (*what != '\0')
+      ++what;
+  }
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/copy.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/copy.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/copy.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr expected(const expected& rhs);
+
+#include <cassert>
+#include <expected>
+
+#include "MoveOnly.h"
+
+struct NotTriviallyCopyConstructible {
+  NotTriviallyCopyConstructible(const NotTriviallyCopyConstructible&);
+};
+
+static_assert(std::is_copy_constructible_v<std::expected<int, int>>);
+static_assert(!std::is_copy_constructible_v<std::expected<MoveOnly, MoveOnly>>);
+static_assert(!std::is_copy_constructible_v<std::expected<MoveOnly, int>>);
+static_assert(!std::is_copy_constructible_v<std::expected<int, MoveOnly>>);
+static_assert(std::is_trivially_copy_constructible_v<std::expected<int, int>>);
+static_assert(std::is_trivially_copy_constructible_v<std::expected<int, int>>);
+static_assert(!std::is_trivially_copy_constructible_v<std::expected<NotTriviallyCopyConstructible, int>>);
+static_assert(!std::is_trivially_copy_constructible_v<std::expected<int, NotTriviallyCopyConstructible>>);
+static_assert(!std::is_trivially_copy_constructible_v<std::expected<NotTriviallyCopyConstructible,
+                                                                    NotTriviallyCopyConstructible>>);
+
+constexpr bool test() {
+  {
+    std::expected<int, int> e(10);
+    auto e2 = e;
+    assert(e2.has_value());
+    assert(*e2 == 10);
+  }
+  {
+    std::expected<int, int> e(std::unexpect, 10);
+    auto e2 = e;
+    assert(!e2.has_value());
+    assert(e2.error() == 10);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/copy_other.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/copy_other.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/copy_other.pass.cpp
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+template <class T>
+struct ConvertibleFrom {
+  T t;
+  constexpr ConvertibleFrom() = default;
+  constexpr ConvertibleFrom(const T& o) : t(o) {}
+};
+static_assert(std::is_convertible_v<int, ConvertibleFrom<int>>);
+
+template <class T>
+struct ConstructibleFrom {
+  T t;
+  constexpr ConstructibleFrom() = default;
+  constexpr explicit ConstructibleFrom(T& o) : t(std::move(o)) {}
+  constexpr explicit ConstructibleFrom(const T& o) : t(o) {}
+  constexpr explicit ConstructibleFrom(T&& o) : t(std::move(o)) {}
+  constexpr explicit ConstructibleFrom(const T&& o) : t(std::move(o)) {}
+};
+
+static_assert(!std::is_constructible_v<std::expected<ConstructibleFrom<std::expected<int, char>>, char>,
+                                       std::expected<int, char>&>);
+
+static_assert(!std::is_constructible_v<std::expected<ConstructibleFrom<std::expected<int, char>>, char>,
+                                       const std::expected<int, char>&>);
+
+constexpr bool test() {
+  std::expected<int, char> e;
+  std::expected<ConvertibleFrom<int>, char> e2 = e;
+  assert(e2.value().t == 0);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/default.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/default.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/default.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr expected();
+
+#include <cassert>
+#include <expected>
+
+struct ThrowOnConstruction {
+  ThrowOnConstruction() { throw 1; }
+};
+
+void test_exception() {
+  try {
+    std::expected<ThrowOnConstruction, int> e;
+  } catch(int) {
+    return;
+  }
+  assert(false);
+}
+
+constexpr bool test() {
+  std::expected<int, int> e;
+  assert(e.has_value());
+  assert(e.value() == 0);
+
+  return true;
+}
+
+int main(int, char**) {
+  test_exception();
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+#include "MoveOnly.h"
+
+struct NonMovable {
+  MoveOnly i;
+
+  constexpr explicit NonMovable(MoveOnly&& i_) : i(std::move(i_)) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::expected<int, char>, std::in_place_t, int, const char*>);
+
+constexpr bool test() {
+  std::expected<NonMovable, int> e(std::in_place, MoveOnly(1));
+  assert(e.value().i.get() == 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place_init_list.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place_init_list.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/in_place_init_list.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+#include "MoveOnly.h"
+
+struct NonMovable {
+  MoveOnly i;
+
+  constexpr explicit NonMovable(std::initializer_list<int>, MoveOnly&& i_) : i(std::move(i_)) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::expected<int, char>, std::in_place_t, int, const char*>);
+
+constexpr bool test() {
+  std::expected<NonMovable, int> e(std::in_place, {1, 2, 3, 4}, MoveOnly(1));
+  assert(e.value().i.get() == 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/move.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/move.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/move.pass.cpp
@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr expected(expected&& rhs) noexcept(see below);
+
+#include <cassert>
+#include <expected>
+
+#include "MoveOnly.h"
+
+static_assert(std::is_move_constructible_v<std::expected<int, int>>);
+static_assert(std::is_move_constructible_v<std::expected<MoveOnly, int>>);
+static_assert(std::is_move_constructible_v<std::expected<int, MoveOnly>>);
+static_assert(std::is_move_constructible_v<std::expected<MoveOnly, MoveOnly>>);
+static_assert(std::is_trivially_move_constructible_v<std::expected<int, int>>);
+static_assert(!std::is_trivially_move_constructible_v<std::expected<MoveOnly, int>>);
+static_assert(!std::is_trivially_move_constructible_v<std::expected<int, MoveOnly>>);
+static_assert(!std::is_trivially_move_constructible_v<std::expected<MoveOnly, MoveOnly>>);
+
+constexpr bool test() {
+  std::expected<MoveOnly, int> e;
+  auto e2 = std::move(e);
+  assert(e2->get() == 1);
+  assert(e->get() == 0);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect.pass.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+
+#include "MoveOnly.h"
+
+struct NonMovable {
+  MoveOnly i;
+
+  constexpr explicit NonMovable(MoveOnly&& i_) : i(std::move(i_)) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::expected<int, char>, std::unexpect_t, int, const char*>);
+
+constexpr bool test() {
+  std::expected<int, NonMovable> e(std::unexpect, MoveOnly(1));
+  assert(e.error().i.get() == 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect_init_list.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect_init_list.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/ctor/unexpect_init_list.pass.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+#include "MoveOnly.h"
+
+struct NonMovable {
+  MoveOnly i;
+
+  constexpr explicit NonMovable(std::initializer_list<int>, MoveOnly&& i_) : i(std::move(i_)) {}
+  NonMovable(NonMovable&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::expected<int, char>, std::unexpect_t, int, const char*>);
+
+constexpr bool test() {
+  std::expected<int, NonMovable> e(std::unexpect, {1, 2, 3, 4}, MoveOnly(1));
+  assert(e.error().i.get() == 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/dtor.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/dtor.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/dtor.pass.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+struct InstanceCounter {
+  int* counter;
+  constexpr InstanceCounter(int* counter_) : counter(counter_) { ++*counter; }
+  constexpr ~InstanceCounter() { --*counter; }
+  InstanceCounter(InstanceCounter&&) = delete;
+};
+
+constexpr bool test() {
+  int instanceCount = 0;
+
+  {
+    std::expected<InstanceCounter, InstanceCounter> e(std::in_place, &instanceCount);
+    assert(instanceCount == 1);
+  }
+  assert(instanceCount == 0);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.unexpected/assign.pass.cpp b/libcxx/test/std/utilities/expected/expected.unexpected/assign.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.unexpected/assign.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr unexpected& operator=(const unexpected&) = default;
+// constexpr unexpected& operator=(unexpected&&) = default;
+
+#include <cassert>
+#include <expected>
+
+#include "MoveOnly.h"
+
+constexpr bool test() {
+  { // constexpr unexpected& operator=(const unexpected&)
+    std::unexpected<int> e(1);
+    std::unexpected<int> e2(45);
+    e2 = e;
+    assert(e2.value() == 1);
+  }
+
+  { // constexpr unexpected& operator=(unexpected&&)
+    std::unexpected<MoveOnly> e(1);
+    std::unexpected<MoveOnly> e2(45);
+    e2 = std::move(e);
+    assert(e2.value().get() == 1);
+    assert(e.value().get() == 0);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.unexpected/ctor.pass.cpp b/libcxx/test/std/utilities/expected/expected.unexpected/ctor.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.unexpected/ctor.pass.cpp
@@ -0,0 +1,213 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr unexpected(const unexpected&) = default;
+// constexpr unexpected(unexpected&&) = default;
+// template<class... Args>
+//     constexpr explicit unexpected(in_place_t, Args&&...);
+// template<class U, class... Args>
+//     constexpr explicit unexpected(in_place_t, initializer_list<U>, Args&&...);
+// template<class Err = E>
+//     constexpr explicit unexpected(Err&&);
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+struct ConstCopyConstructible {
+  constexpr ConstCopyConstructible() = default;
+  constexpr ConstCopyConstructible(const ConstCopyConstructible&) {}
+  constexpr ConstCopyConstructible(ConstCopyConstructible&) = delete;
+  constexpr ConstCopyConstructible(ConstCopyConstructible&&) = delete;
+  constexpr ConstCopyConstructible(const ConstCopyConstructible&&) = delete;
+};
+struct MutableCopyConstructible {
+  constexpr MutableCopyConstructible() = default;
+  constexpr MutableCopyConstructible(MutableCopyConstructible&) {}
+  constexpr MutableCopyConstructible(const MutableCopyConstructible&) = delete;
+};
+struct ConstMoveConstructible {
+  constexpr ConstMoveConstructible() = default;
+  constexpr ConstMoveConstructible(const ConstMoveConstructible&&) {}
+  constexpr ConstMoveConstructible(ConstMoveConstructible&&) = delete;
+};
+struct MutableMoveConstructible {
+  constexpr MutableMoveConstructible() = default;
+  constexpr MutableMoveConstructible(MutableMoveConstructible&&) {}
+  constexpr MutableMoveConstructible(const MutableMoveConstructible&&) = delete;
+};
+
+static_assert( std::is_constructible_v<std::unexpected<MutableCopyConstructible>, MutableCopyConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<MutableCopyConstructible>, const MutableCopyConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<MutableCopyConstructible>, MutableCopyConstructible&&>);
+static_assert(!std::is_constructible_v<std::unexpected<MutableCopyConstructible>, const MutableCopyConstructible&&>);
+
+static_assert(!std::is_constructible_v<std::unexpected<ConstCopyConstructible>, ConstCopyConstructible&>);
+static_assert( std::is_constructible_v<std::unexpected<ConstCopyConstructible>, const ConstCopyConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<ConstCopyConstructible>, ConstCopyConstructible&&>);
+static_assert(!std::is_constructible_v<std::unexpected<ConstCopyConstructible>, const ConstCopyConstructible&&>);
+
+static_assert(!std::is_constructible_v<std::unexpected<MutableMoveConstructible>, MutableMoveConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<MutableMoveConstructible>, const MutableMoveConstructible&>);
+static_assert( std::is_constructible_v<std::unexpected<MutableMoveConstructible>, MutableMoveConstructible&&>);
+static_assert(!std::is_constructible_v<std::unexpected<MutableMoveConstructible>, const MutableMoveConstructible&&>);
+
+static_assert(!std::is_constructible_v<std::unexpected<ConstMoveConstructible>, ConstMoveConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<ConstMoveConstructible>, const ConstMoveConstructible&>);
+static_assert(!std::is_constructible_v<std::unexpected<ConstMoveConstructible>, ConstMoveConstructible&&>);
+static_assert( std::is_constructible_v<std::unexpected<ConstMoveConstructible>, const ConstMoveConstructible&&>);
+
+struct ImmobileRVal {
+  constexpr ImmobileRVal(int&&) {}
+  ImmobileRVal(const ImmobileRVal&) = delete;
+  ImmobileRVal(ImmobileRVal&&) = delete;
+};
+
+struct ImmobileLVal {
+  constexpr ImmobileLVal(int&) {}
+  ImmobileLVal(const ImmobileLVal&) = delete;
+  ImmobileLVal(ImmobileLVal&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRVal>, std::in_place_t, int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRVal>, std::in_place_t, const int&>);
+static_assert( std::is_constructible_v<std::unexpected<ImmobileRVal>, std::in_place_t, int&&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRVal>, std::in_place_t, const int&& >);
+
+static_assert( std::is_constructible_v<std::unexpected<ImmobileLVal>, std::in_place_t, int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLVal>, std::in_place_t, const int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLVal>, std::in_place_t, int&&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLVal>, std::in_place_t, const int&& >);
+
+struct ImmobileRValInitList {
+  constexpr ImmobileRValInitList(std::initializer_list<long>, int&&) {}
+  ImmobileRValInitList(const ImmobileRValInitList&) = delete;
+  ImmobileRValInitList(ImmobileRValInitList&&) = delete;
+};
+
+struct ImmobileLValInitList {
+  constexpr ImmobileLValInitList(std::initializer_list<long>, int&) {}
+  ImmobileLValInitList(const ImmobileLValInitList&) = delete;
+  ImmobileLValInitList(ImmobileLValInitList&&) = delete;
+};
+
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRValInitList>, std::in_place_t, std::initializer_list<long>, int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRValInitList>, std::in_place_t, std::initializer_list<long>, const int&>);
+static_assert( std::is_constructible_v<std::unexpected<ImmobileRValInitList>, std::in_place_t, std::initializer_list<long>, int&&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileRValInitList>, std::in_place_t, std::initializer_list<long>, const int&& >);
+
+static_assert( std::is_constructible_v<std::unexpected<ImmobileLValInitList>, std::in_place_t, std::initializer_list<long>, int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLValInitList>, std::in_place_t, std::initializer_list<long>, const int&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLValInitList>, std::in_place_t, std::initializer_list<long>, int&&>);
+static_assert(!std::is_constructible_v<std::unexpected<ImmobileLValInitList>, std::in_place_t, std::initializer_list<long>, const int&& >);
+
+struct CopyThrows {
+  CopyThrows(const CopyThrows&) noexcept(false) {}
+};
+
+struct CopyNothrow {
+  CopyNothrow(const CopyNothrow&) noexcept(true) {}
+};
+struct MoveThrows {
+  MoveThrows(MoveThrows&&) noexcept(false) {}
+};
+
+struct MoveNothrow {
+  MoveNothrow(MoveNothrow&&) noexcept(true) {}
+};
+
+static_assert(!std::is_nothrow_copy_constructible_v<CopyThrows>);
+static_assert( std::is_nothrow_copy_constructible_v<CopyNothrow>);
+static_assert(!std::is_nothrow_move_constructible_v<MoveThrows>);
+static_assert( std::is_nothrow_move_constructible_v<MoveNothrow>);
+
+constexpr bool test() {
+  { // test unexpected(_Err&&)
+    {
+      std::unexpected<int> e {1L};
+      assert(e.value() == 1);
+    }
+    {
+      const ConstCopyConstructible a;
+      [[maybe_unused]] std::unexpected<ConstCopyConstructible> e {a};
+    }
+    {
+      MutableCopyConstructible a;
+      [[maybe_unused]] std::unexpected<MutableCopyConstructible> e {a};
+    }
+    {
+      const ConstMoveConstructible a;
+      [[maybe_unused]] std::unexpected<ConstMoveConstructible> e {std::move(a)};
+    }
+    {
+      MutableMoveConstructible a;
+      [[maybe_unused]] std::unexpected<MutableMoveConstructible> e {std::move(a)};
+    }
+  }
+
+  { // test unexpected(in_place_t, _Args&&... __args)
+    {
+      [[maybe_unused]] std::unexpected<ImmobileRVal> e {std::in_place_t{}, 1};
+    }
+    {
+      int i = 1;
+      [[maybe_unused]] std::unexpected<ImmobileLVal> e {std::in_place_t{}, i};
+    }
+  }
+
+  { // test unexpected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+    {
+      [[maybe_unused]] std::unexpected<ImmobileRValInitList> e {std::in_place_t{}, {2L}, 1};
+    }
+    {
+      int i = 1;
+      [[maybe_unused]] std::unexpected<ImmobileLValInitList> e {std::in_place_t{}, {2L}, i};
+    }
+  }
+
+  { // test unexpected(const unexpected&)
+    struct CopyCounter {
+      int* counter;
+      constexpr CopyCounter(int* counter_) : counter(counter_) {}
+      constexpr CopyCounter(const CopyCounter& other) : counter(other.counter) { ++*counter; }
+    };
+
+    int counter = 0;
+    std::unexpected<CopyCounter> e { &counter };
+    auto e2 = e;
+    auto e3 = std::move(e);
+    assert(counter == 2);
+  }
+
+  { // test unexpected(unexpected&&)
+    struct MoveCounter {
+      int* counter;
+      constexpr MoveCounter(int* counter_) : counter(counter_) {}
+      constexpr MoveCounter(MoveCounter&& other) : counter(other.counter) { ++*counter; }
+    };
+
+    int counter = 0;
+    std::unexpected<MoveCounter> e { &counter };
+    auto e3 = std::move(e);
+    assert(counter == 1);
+  }
+
+  std::unexpected<int> a {1};
+  assert(a.value() == 1);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}
diff --git a/libcxx/test/std/utilities/expected/expected.unexpected/equality.pass.cpp b/libcxx/test/std/utilities/expected/expected.unexpected/equality.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.unexpected/equality.pass.cpp
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+struct Comparable {
+  bool compare;
+  int* set;
+
+  constexpr bool operator==(const Comparable&) const {
+    *set = 42;
+    return compare;
+  }
+};
+
+constexpr bool test() {
+  int first = 0;
+  int second = 0;
+  std::unexpected<Comparable> e1(Comparable{true, &first});
+  std::unexpected<Comparable> e2(Comparable{true, &second});
+  assert(e1 == e2);
+  assert(first == 42);
+  assert(second == 0);
+  assert(e2 == e1);
+  assert(first == 42);
+  assert(second == 42);
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.unexpected/swap.pass.cpp b/libcxx/test/std/utilities/expected/expected.unexpected/swap.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.unexpected/swap.pass.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+#include <cassert>
+#include <expected>
+#include <utility>
+
+struct CustomSwap { int i; };
+
+constexpr void swap(CustomSwap& lhs, CustomSwap& rhs) {
+  lhs.i *= 2;
+  rhs.i /= 2;
+}
+
+constexpr bool test() {
+  {
+    std::unexpected<CustomSwap> e1(CustomSwap{30});
+    std::unexpected<CustomSwap> e2(CustomSwap{20});
+    e1.swap(e2);
+    assert(e1.value().i == 60);
+    assert(e2.value().i = 10);
+  }
+
+  {
+    std::unexpected<CustomSwap> e1(CustomSwap{30});
+    std::unexpected<CustomSwap> e2(CustomSwap{20});
+    swap(e1, e2);
+    assert(e1.value().i == 60);
+    assert(e2.value().i = 10);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.unexpected/value.pass.cpp b/libcxx/test/std/utilities/expected/expected.unexpected/value.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.unexpected/value.pass.cpp
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// <expected>
+
+// constexpr const E& value() const & noexcept;
+// constexpr E& value() & noexcept;
+// constexpr const E&& value() const && noexcept;
+// constexpr E&& value() && noexcept;
+
+#include <cassert>
+#include <expected>
+#include <ranges>
+
+#include "MoveOnly.h"
+
+constexpr bool test() {
+  { // constexpr const E& value() const & noexcept;
+    const std::unexpected<int> e(45);
+    std::same_as<const int&> decltype(auto) val = e.value();
+    assert(val == 45);
+  }
+
+  { // constexpr E& value() & noexcept;
+    std::unexpected<int> e(45);
+    std::same_as<int&> decltype(auto) val = e.value();
+    assert(val == 45);
+  }
+
+  { // constexpr const E&& value() const && noexcept;
+    const std::unexpected<MoveOnly> e(45);
+    std::same_as<const MoveOnly&&> decltype(auto) val = std::move(e).value();
+    assert(val == 45);
+  }
+
+  { // constexpr E& value() & noexcept;
+    std::unexpected<MoveOnly> e(45);
+    std::same_as<MoveOnly&&> decltype(auto) val = std::move(e).value();
+    assert(val == 45);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
diff --git a/libcxx/utils/generate_feature_test_macro_components.py b/libcxx/utils/generate_feature_test_macro_components.py
--- a/libcxx/utils/generate_feature_test_macro_components.py
+++ b/libcxx/utils/generate_feature_test_macro_components.py
@@ -303,6 +303,10 @@
     "values": { "c++17": 201603, "c++20": 201902 },
     "headers": ["execution"],
     "unimplemented": True,
+  }, {
+    "name": "__cpp_lib_expected",
+    "values": { "c++2b": 202202 },
+    "headers": ["expected"],
   }, {
     "name": "__cpp_lib_filesystem",
     "values": { "c++17": 201703 },