diff --git a/libcxx/docs/Status/Cxx2bPapers.csv b/libcxx/docs/Status/Cxx2bPapers.csv
--- a/libcxx/docs/Status/Cxx2bPapers.csv
+++ b/libcxx/docs/Status/Cxx2bPapers.csv
@@ -100,7 +100,7 @@
 "`P1478R8 <https://wg21.link/P1478R8>`__","LWG", "``Byte-wise`` ``atomic`` ``memcpy``", "November 2022","","","|concurrency TS|"
 "`P2167R3 <https://wg21.link/P2167R3>`__","LWG", "Improved Proposed Wording for LWG 2114", "November 2022","","",""
 "`P2396R1 <https://wg21.link/P2396R1>`__","LWG", "Concurrency TS 2 fixes ", "November 2022","","","|concurrency TS|"
-"`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","","",""
+"`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","July 2022","|Complete|","16.0"
 "`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","","","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
diff --git a/libcxx/include/__expected/expected.h b/libcxx/include/__expected/expected.h
--- a/libcxx/include/__expected/expected.h
+++ b/libcxx/include/__expected/expected.h
@@ -14,10 +14,12 @@
 #include <__expected/bad_expected_access.h>
 #include <__expected/unexpect.h>
 #include <__expected/unexpected.h>
+#include <__functional/invoke.h>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/disjunction.h>
+#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
@@ -60,8 +62,20 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _Tp, class _Err>
+class expected;
+
 namespace __expected {
 
+template <class _Tp>
+struct __is_expected : false_type {};
+
+template <class _Tp, class _Err>
+struct __is_expected<expected<_Tp, _Err>> : true_type {};
+
+struct __expected_construct_in_place_from_invoke_tag {};
+struct __expected_construct_unexpected_from_invoke_tag {};
+
 template <class _Err, class _Arg>
 _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
 #  ifndef _LIBCPP_NO_EXCEPTIONS
@@ -166,6 +180,15 @@
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>> >;
 
+  template <class _Func, class... _Args>
+  constexpr explicit expected(
+      __expected::__expected_construct_in_place_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
+      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(true) {}
+
+  template <class _Func, class... _Args>
+  constexpr explicit expected(
+      __expected::__expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
+      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {}
 
 public:
   template <class _Up, class _OtherErr>
@@ -595,6 +618,227 @@
     return __has_val_ ? std::move(__union_.__val_) : static_cast<_Tp>(std::forward<_Up>(__v));
   }
 
+  template <class _Up = _Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) const& {
+    static_assert(is_copy_constructible_v<_Err>, "error_type has to be move constructible");
+    static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type");
+    return __has_val_ ? static_cast<_Err>(std::forward<_Up>(__v)) : __union_.__unex_;
+  }
+
+  template <class _Up = _Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) && {
+    static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible");
+    static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type");
+    return __has_val_ ? static_cast<_Err>(std::forward<_Up>(__v)) : std::move(__union_.__unex_);
+  }
+
+  // [expected.void.monadic], monadic
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(value()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<decltype(f(value()))>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f), value());
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(value()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<decltype(f(value()))>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f), value());
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(value())) must be a specialization of std::expected");
+    static_assert(
+        is_same_v<typename _Up::error_type, _Err>,
+        "std::remove_cvref_t<invoke_result_t<F, decltype(std::move(value()))>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+    }
+    return _Up(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(value())) must be a specialization of std::expected");
+    static_assert(
+        is_same_v<typename _Up::error_type, _Err>,
+        "std::remove_cvref_t<invoke_result_t<F, decltype(std::move(value()))>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+    }
+    return _Up(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(error()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(error()))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up(in_place, value());
+    }
+    return std::invoke(std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(error()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(error()))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up(in_place, value());
+    }
+    return std::invoke(std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(std::move(error())))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up(in_place, std::move(value()));
+    }
+    return std::invoke(std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(std::move(error())))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up(in_place, std::move(value()));
+    }
+    return std::invoke(std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      } else {
+        std::invoke(std::forward<_Func>(__f), value());
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      } else {
+        std::invoke(std::forward<_Func>(__f), value());
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+      } else {
+        std::invoke(std::forward<_Func>(__f), std::move(value()));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+      } else {
+        std::invoke(std::forward<_Func>(__f), std::move(value()));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, value());
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, value());
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, std::move(value()));
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Tp> _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place, std::move(value()));
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
+  }
+
   // [expected.object.eq], equality operators
   template <class _T2, class _E2>
     requires(!is_void_v<_T2>)
@@ -626,6 +870,16 @@
   _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
     _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
 
+    template <class _Func, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
+        __expected::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
+    template <class _Func, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
+        __expected::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
     _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
       requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
     = default;
@@ -759,6 +1013,19 @@
     std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
   }
 
+private:
+  template <class _Func>
+  constexpr explicit expected(__expected::__expected_construct_in_place_from_invoke_tag, _Func&& __f)
+      : __has_val_(true) {
+    std::invoke(std::forward<_Func>(__f));
+  }
+
+  template <class _Func, class... _Args>
+  constexpr explicit expected(
+      __expected::__expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
+      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {}
+
+public:
   // [expected.void.dtor], destructor
 
   _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
@@ -926,6 +1193,221 @@
     return std::move(__union_.__unex_);
   }
 
+  template <class _Up = _Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) const& {
+    static_assert(is_copy_constructible_v<_Err>, "error_type has to be move constructible");
+    static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type");
+    return __has_val_ ? static_cast<_Err>(std::forward<_Up>(__v)) : __union_.__unex_;
+  }
+
+  template <class _Up = _Err>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err error_or(_Up&& __v) && {
+    static_assert(is_move_constructible_v<_Err>, "error_type has to be move constructible");
+    static_assert(is_convertible_v<_Up, _Err>, "argument has to be convertible to error_type");
+    return __has_val_ ? static_cast<_Err>(std::forward<_Up>(__v)) : std::move(__union_.__unex_);
+  }
+
+  // [expected.void.monadic], monadic
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value, "result of f() must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<invoke_result_t<F>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f));
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value, "result of f() must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<invoke_result_t<F>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f));
+    }
+    return _Up(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value, "result of f() must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<invoke_result_t<F>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f));
+    }
+    return _Up(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func>>;
+    static_assert(__expected::__is_expected<_Up>::value, "result of f() must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::error_type, _Err>,
+                  "std::remove_cvref_t<invoke_result_t<F>>::error_type must same as error_type");
+    if (has_value()) {
+      return std::invoke(std::forward<_Func>(__f));
+    }
+    return _Up(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) & {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(error()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(error()))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up();
+    }
+    return std::invoke(std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&>>;
+    static_assert(
+        __expected::__is_expected<_Up>::value, "result of f(error()) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(error()))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up();
+    }
+    return std::invoke(std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(std::move(error())))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up();
+    }
+    return std::invoke(std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
+    static_assert(__expected::__is_expected<_Up>::value,
+                  "result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(is_same_v<typename _Up::value_type, _Tp>,
+                  "std::remove_cvref_t<decltype(f(std::move(error())))>::value_type must same as value_type");
+    if (has_value()) {
+      return _Up();
+    }
+    return std::invoke(std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f));
+      } else {
+        std::invoke(std::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_copy_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f));
+      } else {
+        std::invoke(std::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, error());
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f));
+      } else {
+        std::invoke(std::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  requires is_move_constructible_v<_Err> _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func>>;
+    if (has_value()) {
+      if constexpr (!is_void_v<_Up>) {
+        return expected<_Up, _Err>(
+            __expected::__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f));
+      } else {
+        std::invoke(std::forward<_Func>(__f));
+        return expected<_Up, _Err>();
+      }
+    }
+    return expected<_Up, _Err>(unexpect, std::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>();
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
+  }
+
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto transform_error(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Err&&>>;
+    if (has_value()) {
+      return expected<_Tp, _Up>(in_place);
+    }
+    return expected<_Tp, _Up>(
+        __expected::__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
+  }
+
   // [expected.void.eq], equality operators
   template <class _T2, class _E2>
     requires is_void_v<_T2>
@@ -948,6 +1430,11 @@
   _LIBCPP_NO_UNIQUE_ADDRESS union __union_t {
     _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
 
+    template <class _Func, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
+        __expected::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
     _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
       requires(is_trivially_destructible_v<_Err>)
     = default;
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/monadic/and_then.pass.cpp
@@ -0,0 +1,268 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto and_then(F&& f) &;
+// template<class F> constexpr auto and_then(F&& f) const &;
+// template<class F> constexpr auto and_then(F&& f) &&;
+// template<class F> constexpr auto and_then(F&& f) const &&;
+
+#include <cassert>
+#include <expected>
+#include <type_traits>
+
+struct LVal {
+  constexpr std::expected<int, int> operator()(int&) { return 1; }
+  std::expected<int, int> operator()(const int&)  = delete;
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return 1; }
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct RVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return 1; }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&)      = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr std::expected<int, int> operator()(int) & { return 1; }
+  std::expected<int, int> operator()(int) const&  = delete;
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return 1; }
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return 1; }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) &&     = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return 1; }
+};
+
+struct NOLVal {
+  constexpr std::expected<int, int> operator()(int&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(const int&)  = delete;
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NOCLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NORVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct NOCRVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&)      = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return std::expected<int, int>(std::unexpected<int>(5)); }
+};
+
+struct NORefQual {
+  constexpr std::expected<int, int> operator()(int) & { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) const&  = delete;
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NOCRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NORVRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return std::expected<int, int>(std::unexpected<int>(5)); }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct NORVCRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) &&     = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return std::expected<int, int>(std::unexpected<int>(5)); }
+};
+
+struct NonCopy {
+  NonCopy() = default;
+  NonCopy(const NonCopy&) { assert(false); }
+  std::expected<int, int> operator()(const NonCopy&&) { return 1; }
+};
+
+struct NonConst {
+  std::expected<int, int> non_const() { return 1; }
+};
+
+// clang-format off
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without &qualifier on F'soperator()
+    {
+      std::expected<int, int> e{0};
+      assert(e.and_then(LVal{}).value() == 1);
+      assert(e.and_then(NOLVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      RefQual l{};
+      assert(e.and_then(l) == 1);
+      NORefQual nl{};
+      assert(e.and_then(nl).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      assert(e.and_then(CLVal{}).value() == 1);
+      assert(e.and_then(NOCLVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      const CRefQual l{};
+      assert(e.and_then(l) == 1);
+      const NOCRefQual nl{};
+      assert(e.and_then(nl).error() == 5);
+      static_assert(std::is_same_v<decltype(e.and_then(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      assert(std::move(e).and_then(RVal{}) == 1);
+      assert(std::move(e).and_then(NORVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(RVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e{0};
+      assert(e.and_then(RVRefQual{}) == 1);
+      assert(e.and_then(NORVRefQual{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      assert(std::move(e).and_then(CRVal{}) == 1);
+      assert(std::move(e).and_then(NOCRVal{}).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e{0};
+      const RVCRefQual l{};
+      assert(std::move(e).and_then(std::move(l)) == 1);
+      const NORVCRefQual nl{};
+      assert(std::move(e).and_then(std::move(nl)).error() == 5);
+      static_assert(std::is_same_v<decltype(std::move(e).and_then(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+// clang-format on
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<NonConst, int> e(std::unexpected<int>(2));
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.and_then(l);
+  std::move(e).and_then(l);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+
+  std::expected<int, int> e(std::unexpected<int>(1));
+  const auto& ce = e;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e.and_then(never_called);
+  std::move(e).and_then(never_called);
+  ce.and_then(never_called);
+  std::move(ce).and_then(never_called);
+
+  std::expected<NonCopy, int> nc(std::unexpect, 0);
+  const auto& cnc = nc;
+  std::move(nc).and_then(NonCopy{});
+  std::move(cnc).and_then(NonCopy{});
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/monadic/or_else.pass.cpp
@@ -0,0 +1,198 @@
+//===----------------------------------------------------------------------===//
+// 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>
+
+// template<class F> constexpr auto or_else(F&& f) &;
+// template<class F> constexpr auto or_else(F&& f) const &;
+// template<class F> constexpr auto or_else(F&& f) &&;
+// template<class F> constexpr auto or_else(F&& f) const &&;
+
+#include <cassert>
+#include <expected>
+#include <type_traits>
+
+struct LVal {
+  constexpr std::expected<int, int> operator()(int&) { return 1; }
+  std::expected<int, int> operator()(const int&)  = delete;
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  std::expected<int, int> operator()(int&) = delete;
+  constexpr std::expected<int, int> operator()(const int&) { return 1; }
+  std::expected<int, int> operator()(int&&)       = delete;
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct RVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  constexpr std::expected<int, int> operator()(int&&) { return 1; }
+  std::expected<int, int> operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  std::expected<int, int> operator()(int&)       = delete;
+  std::expected<int, int> operator()(const int&) = delete;
+  std::expected<int, int> operator()(int&&)      = delete;
+  constexpr std::expected<int, int> operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr std::expected<int, int> operator()(int) & { return 1; }
+  std::expected<int, int> operator()(int) const&  = delete;
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  std::expected<int, int> operator()(int) & = delete;
+  constexpr std::expected<int, int> operator()(int) const& { return 1; }
+  std::expected<int, int> operator()(int) &&      = delete;
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  constexpr std::expected<int, int> operator()(int) && { return 1; }
+  std::expected<int, int> operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  std::expected<int, int> operator()(int) &      = delete;
+  std::expected<int, int> operator()(int) const& = delete;
+  std::expected<int, int> operator()(int) &&     = delete;
+  constexpr std::expected<int, int> operator()(int) const&& { return 1; }
+};
+
+struct NonCopy {
+  NonCopy() = default;
+  NonCopy(const NonCopy&) { assert(false); }
+  std::expected<int, int> operator()(const NonCopy&&) { return 1; }
+};
+
+// clang-format off
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.or_else(LVal{}) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      RefQual l{};
+      assert(e.or_else(l) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.or_else(CLVal{}) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const CRefQual l{};
+      assert(e.or_else(l) == 1);
+      static_assert(std::is_same_v<decltype(e.or_else(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(RVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(RVal{})), std::expected<int, int>>);
+    }
+
+    // With && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(RVRefQual{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).or_else(CRVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const RVCRefQual l{};
+      assert(std::move(e).or_else(std::move(l)) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).or_else(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+// clang-format on
+
+struct NonConst {
+  std::expected<int, int> non_const() { return std::expected<int, int>(std::unexpect, 1); }
+};
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<int, NonConst> e{1};
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.or_else(l);
+  std::move(e).or_else(l);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+
+  std::expected<int, int> e(1);
+  const auto& ce = e;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e.or_else(never_called);
+  std::move(e).or_else(never_called);
+  ce.or_else(never_called);
+  std::move(ce).or_else(never_called);
+
+  std::expected<int, NonCopy> nc(0);
+  const auto& cnc = nc;
+  std::move(nc).or_else(NonCopy{});
+  std::move(cnc).or_else(NonCopy{});
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform.pass.cpp
@@ -0,0 +1,234 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform(F&& f) &;
+// template<class F> constexpr auto transform(F&& f) const &;
+// template<class F> constexpr auto transform(F&& f) &&;
+// template<class F> constexpr auto transform(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+struct LVal {
+  constexpr int operator()(int&) { return 1; }
+  int operator()(const int&)  = delete;
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  int operator()(int&) = delete;
+  constexpr int operator()(const int&) { return 1; }
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct RVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  constexpr int operator()(int&&) { return 1; }
+  int operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  int operator()(int&&)      = delete;
+  constexpr int operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr int operator()(int) & { return 1; }
+  int operator()(int) const&  = delete;
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  int operator()(int) & = delete;
+  constexpr int operator()(int) const& { return 1; }
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  constexpr int operator()(int) && { return 1; }
+  int operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  int operator()(int) &&     = delete;
+  constexpr int operator()(int) const&& { return 1; }
+};
+
+struct NonCopy {
+  int value;
+  constexpr explicit NonCopy(int val) : value(val) {}
+  NonCopy(const NonCopy&) = delete;
+};
+
+struct NonConst {
+  int non_const() { return 1; }
+};
+
+// clang-format off
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without &qualifier on F'soperator()
+    {
+      std::expected<int, int> e(0);
+      assert(e.transform(LVal{}).value() == 1);
+      static_assert(std::is_same_v<decltype(e.transform(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      RefQual l{};
+      assert(e.transform(l) == 1);
+      static_assert(std::is_same_v<decltype(e.transform(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      assert(e.transform(CLVal{}).value() == 1);
+      static_assert(std::is_same_v<decltype(e.transform(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      const CRefQual l{};
+      assert(e.transform(l).value() == 1);
+      static_assert(std::is_same_v<decltype(e.transform(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      assert(std::move(e).transform(RVal{}).value() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(RVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(0);
+      assert(e.transform(RVRefQual{}).value() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      assert(std::move(e).transform(CRVal{}) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      const std::expected<int, int> e(0);
+      const RVCRefQual l{};
+      assert(e.transform(std::move(l)) == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+// clang-format on
+
+constexpr void test_take_val_return_void() {
+  std::expected<int, int> e(1);
+  int val = 0;
+  e.transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, int&>);
+    assert(val == 0);
+    val = 1;
+  });
+  assert(val == 1);
+  std::move(e).transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, int>);
+    assert(val == 1);
+    val = 2;
+  });
+
+  const auto& ce = e;
+  assert(val == 2);
+  ce.transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, const int&>);
+    assert(val == 2);
+    val = 3;
+  });
+  assert(val == 3);
+  std::move(ce).transform([&val]<typename T>(T&&) -> void {
+    static_assert(std::is_same_v<T, const int>);
+    assert(val == 3);
+    val = 4;
+  });
+  assert(val == 4);
+}
+
+// check val member is direct-non-list-initialized with invoke(std::forward<F>(f), value())
+constexpr void test_direct_non_list_init() {
+  auto xform = [](int i) { return NonCopy(i); };
+  std::expected<int, int> e(2);
+  std::expected<NonCopy, int> n = e.transform(xform);
+  assert(n.value().value == 2);
+}
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<NonConst, int> e(std::unexpected<int>(2));
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.transform(l);
+  std::move(e).transform(l);
+
+  std::expected<int, int> e1(std::unexpected<int>(1));
+  const auto& ce1         = e1;
+  const auto never_called = [](int) {
+    assert(false);
+    return std::expected<int, int>();
+  };
+
+  e1.transform(never_called);
+  std::move(e1).transform(never_called);
+  ce1.and_then(never_called);
+  std::move(ce1).transform(never_called);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+  test_direct_non_list_init();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/monadic/transform_error.pass.cpp
@@ -0,0 +1,204 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+struct LVal {
+  constexpr int operator()(int&) { return 1; }
+  int operator()(const int&)  = delete;
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct CLVal {
+  int operator()(int&) = delete;
+  constexpr int operator()(const int&) { return 1; }
+  int operator()(int&&)       = delete;
+  int operator()(const int&&) = delete;
+};
+
+struct RVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  constexpr int operator()(int&&) { return 1; }
+  int operator()(const int&&) = delete;
+};
+
+struct CRVal {
+  int operator()(int&)       = delete;
+  int operator()(const int&) = delete;
+  int operator()(int&&)      = delete;
+  constexpr int operator()(const int&&) { return 1; }
+};
+
+struct RefQual {
+  constexpr int operator()(int) & { return 1; }
+  int operator()(int) const&  = delete;
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct CRefQual {
+  int operator()(int) & = delete;
+  constexpr int operator()(int) const& { return 1; }
+  int operator()(int) &&      = delete;
+  int operator()(int) const&& = delete;
+};
+
+struct RVRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  constexpr int operator()(int) && { return 1; }
+  int operator()(int) const&& = delete;
+};
+
+struct RVCRefQual {
+  int operator()(int) &      = delete;
+  int operator()(int) const& = delete;
+  int operator()(int) &&     = delete;
+  constexpr int operator()(int) const&& { return 1; }
+};
+
+struct NonCopy {
+  int value;
+  constexpr explicit NonCopy(int val) : value(val) {}
+  NonCopy(const NonCopy&) = delete;
+};
+
+struct NonConst {
+  int non_const() { return 1; }
+};
+
+// clang-format off
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    // Without & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.transform_error(LVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(LVal{})), std::expected<int, int>>);
+    }
+
+    // With & qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      RefQual l{};
+      assert(e.transform_error(l).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test const& overload
+  {
+    // Without const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(e.transform_error(CLVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(CLVal{})), std::expected<int, int>>);
+    }
+
+    // With const& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const CRefQual l{};
+      assert(e.transform_error(l).error() == 1);
+      static_assert(std::is_same_v<decltype(e.transform_error(l)), std::expected<int, int>>);
+    }
+  }
+
+  // Test && overload
+  {
+    // Without && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(RVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(RVal{})), std::expected<int, int>>);
+    }
+
+    // With && qualifier on F's operator()
+    {
+      std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(RVRefQual{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(RVRefQual{})), std::expected<int, int>>);
+    }
+  }
+
+  // Test const&& overload
+  {
+    // Without const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      assert(std::move(e).transform_error(CRVal{}).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(CRVal{})), std::expected<int, int>>);
+    }
+
+    // With const&& qualifier on F's operator()
+    {
+      const std::expected<int, int> e(std::unexpected<int>(0));
+      const RVCRefQual l{};
+      assert(std::move(e).transform_error(std::move(l)).error() == 1);
+      static_assert(std::is_same_v<decltype(std::move(e).transform_error(std::move(l))), std::expected<int, int>>);
+    }
+  }
+}
+// clang-format on
+
+// check unex member is direct-non-list-initialized with invoke(std::forward<F>(f), error())
+constexpr void test_direct_non_list_init() {
+  auto xform = [](int i) { return NonCopy(i); };
+  std::expected<int, int> e(std::unexpected<int>(2));
+  std::expected<int, NonCopy> n = e.transform_error(xform);
+  assert(n.error().value == 2);
+}
+
+// check that the lambda body is not instantiated during overload resolution
+constexpr void test_sfinae() {
+  std::expected<int, NonConst> e(2);
+  auto l = [](auto&& x) { return x.non_const(); };
+  e.transform_error(l);
+  std::move(e).transform_error(l);
+
+  std::expected<int, int> e1;
+  const auto& ce1 = e1;
+
+  const auto never_called = [](int) {
+    assert(false);
+    return 0;
+  };
+
+  e1.transform_error(never_called);
+  std::move(e1).transform_error(never_called);
+  ce1.transform_error(never_called);
+  std::move(ce1).transform_error(never_called);
+}
+
+constexpr bool test() {
+  test_sfinae();
+  test_val_types();
+  test_direct_non_list_init();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.expected/observers/error_or.pass.cpp b/libcxx/test/std/utilities/expected/expected.expected/observers/error_or.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.expected/observers/error_or.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
+
+// template<class G = E> constexpr E error_or(G&& e) const &;
+// template<class G = E> constexpr E error_or(G&& e) &&;
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+constexpr bool test() {
+  // const &, has_value()
+  {
+    const std::expected<int, int> e(5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 10);
+  }
+
+  // const &, !has_value()
+  {
+    const std::expected<int, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 5);
+  }
+
+  // &&, has_value()
+  {
+    std::expected<int, int> e(5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 10);
+  }
+
+  // &&, !has_value()
+  {
+    std::expected<int, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}
diff --git a/libcxx/test/std/utilities/expected/expected.void/monadic/and_then.pass.cpp b/libcxx/test/std/utilities/expected/expected.void/monadic/and_then.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.void/monadic/and_then.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto and_then(F&& f) &;
+// template<class F> constexpr auto and_then(F&& f) const &;
+// template<class F> constexpr auto and_then(F&& f) &&;
+// template<class F> constexpr auto and_then(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    std::expected<void, int> v;
+    assert(v.and_then(l).value() == 2);
+    static_assert(std::is_same_v< decltype(v.and_then(l)), std::expected<int, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    const std::expected<void, int> v;
+    assert(v.and_then(l).value() == 2);
+    static_assert(std::is_same_v< decltype(v.and_then(l)), std::expected<int, int>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    std::expected<void, int> v;
+    assert(std::move(v).and_then(l).value() == 2);
+    static_assert(std::is_same_v< decltype(std::move(v).and_then(l)), std::expected<int, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> std::expected<int, int> { return 2; };
+    const std::expected<void, int> v;
+    assert(std::move(v).and_then(l).value() == 2);
+    static_assert(std::is_same_v< decltype(std::move(v).and_then(l)), std::expected<int, int>>);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.and_then(f).error() == 2);
+    static_assert(std::is_same_v< decltype(v.and_then(f)), std::expected<int, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.and_then(f).error() == 2);
+    static_assert(std::is_same_v< decltype(v.and_then(f)), std::expected<int, int>>);
+  }
+
+  // Test && overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).and_then(f).error() == 2);
+    static_assert(std::is_same_v< decltype(std::move(v).and_then(f)), std::expected<int, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto f = [] -> std::expected<int, int> { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).and_then(f).error() == 2);
+    static_assert(std::is_same_v< decltype(std::move(v).and_then(f)), std::expected<int, int>>);
+  }
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.void/monadic/or_else.pass.cpp b/libcxx/test/std/utilities/expected/expected.void/monadic/or_else.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.void/monadic/or_else.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto or_else(F&& f) &;
+// template<class F> constexpr auto or_else(F&& f) const &;
+// template<class F> constexpr auto or_else(F&& f) &&;
+// template<class F> constexpr auto or_else(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(v.or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(v.or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(v.or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { return {}; };
+    const std::expected<void, int> v(std::unexpected<int>(1));
+    assert(std::move(v).or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).or_else(l)), std::expected<void, long>>);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    std::expected<void, int> v;
+    assert(v.or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(v.or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    const std::expected<void, int> v;
+    assert(v.or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(v.or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).or_else(l)), std::expected<void, long>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> std::expected<void, long> { throw 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).or_else(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).or_else(l)), std::expected<void, long>>);
+  }
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.void/monadic/transform.pass.cpp b/libcxx/test/std/utilities/expected/expected.void/monadic/transform.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.void/monadic/transform.pass.cpp
@@ -0,0 +1,101 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [] -> int { return 1; };
+    std::expected<void, int> v;
+    assert(v.transform(l).value() == 1);
+    static_assert(std::is_same_v<decltype(v.transform(l)), std::expected<int, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> int { return 1; };
+    const std::expected<void, int> v;
+    assert(v.transform(l).value() == 1);
+    static_assert(std::is_same_v<decltype(v.transform(l)), std::expected<int, int>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> int { return 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).transform(l).value() == 1);
+    static_assert(std::is_same_v<decltype(std::move(v).transform(l)), std::expected<int, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> int { return 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).transform(l).value() == 1);
+    static_assert(std::is_same_v<decltype(std::move(v).transform(l)), std::expected<int, int>>);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [] -> int { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(5));
+    assert(v.transform(l).error() == 5);
+    static_assert(std::is_same_v<decltype(v.transform(l)), std::expected<int, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [] -> int { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(5));
+    assert(v.transform(l).error() == 5);
+    static_assert(std::is_same_v<decltype(v.transform(l)), std::expected<int, int>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [] -> int { throw 1; };
+    std::expected<void, int> v(std::unexpected<int>(5));
+    assert(std::move(v).transform(l).error() == 5);
+    static_assert(std::is_same_v<decltype(std::move(v).transform(l)), std::expected<int, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [] -> int { throw 1; };
+    const std::expected<void, int> v(std::unexpected<int>(5));
+    assert(std::move(v).transform(l).error() == 5);
+    static_assert(std::is_same_v<decltype(std::move(v).transform(l)), std::expected<int, int>>);
+  }
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.void/monadic/transform_error.pass.cpp b/libcxx/test/std/utilities/expected/expected.void/monadic/transform_error.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.void/monadic/transform_error.pass.cpp
@@ -0,0 +1,116 @@
+//===----------------------------------------------------------------------===//
+// 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
+
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
+
+// <expected>
+
+// template<class F> constexpr auto transform_error(F&& f) &;
+// template<class F> constexpr auto transform_error(F&& f) const &;
+// template<class F> constexpr auto transform_error(F&& f) &&;
+// template<class F> constexpr auto transform_error(F&& f) const &&;
+
+#include <expected>
+#include <cassert>
+#include <type_traits>
+
+struct NonCopy {
+  int value;
+  constexpr explicit NonCopy(int val) : value(val) {}
+  NonCopy(const NonCopy&) = delete;
+};
+
+constexpr void test_val_types() {
+  // Test & overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.transform_error(l).error() == 1);
+    static_assert(std::is_same_v<decltype(v.transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(v.transform_error(l).error() == 1);
+    static_assert(std::is_same_v<decltype(v.transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).transform_error(l).error() == 1);
+    static_assert(std::is_same_v<decltype(std::move(v).transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> int { return 1; };
+    const std::expected<void, int> v(std::unexpected<int>(2));
+    assert(std::move(v).transform_error(l).error() == 1);
+    static_assert(std::is_same_v<decltype(std::move(v).transform_error(l)), std::expected<void, int>>);
+  }
+}
+
+constexpr void test_fail() {
+  // Test & overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+    static_assert(std::is_same_v<decltype(v.transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test const& overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(v.transform_error(l).has_value());
+    static_assert(std::is_same_v<decltype(v.transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test && overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).transform_error(l)), std::expected<void, int>>);
+  }
+
+  // Test const&& overload
+  {
+    auto l = [](auto) -> int { throw 1; };
+    const std::expected<void, int> v;
+    assert(std::move(v).transform_error(l).has_value());
+    static_assert(std::is_same_v<decltype(std::move(v).transform_error(l)), std::expected<void, int>>);
+  }
+}
+
+// check unex member is direct-non-list-initialized with invoke(std::forward<F>(f))
+constexpr void test_direct_non_list_init() {
+  auto x = [](int i) { return NonCopy(i); };
+  std::expected<void, int> v(std::unexpected<int>(2));
+  std::expected<void, NonCopy> nv = v.transform_error(x);
+  assert(nv.error().value == 2);
+}
+
+constexpr bool test() {
+  test_fail();
+  test_val_types();
+  test_direct_non_list_init();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+  return 0;
+}
diff --git a/libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp b/libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/utilities/expected/expected.void/observers/error_or.pass.cpp
@@ -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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template<class G = E> constexpr E error_or(G&& e) const &;
+// template<class G = E> constexpr E error_or(G&& e) &&;
+
+#include <cassert>
+#include <concepts>
+#include <expected>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  // const &, has_value()
+  {
+    const std::expected<void, int> e;
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 10);
+  }
+
+  // const &, !has_value()
+  {
+    const std::expected<void, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = e.error_or(10);
+    assert(x == 5);
+  }
+
+  // &&, has_value()
+  {
+    std::expected<void, int> e;
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 10);
+  }
+
+  // &&, !has_value()
+  {
+    std::expected<void, int> e(std::unexpect, 5);
+    std::same_as<int> decltype(auto) x = std::move(e).error_or(10);
+    assert(x == 5);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}